add supporer key program

server/db/schema.ts

@@ -405,6 +405,15 @@ export const resourceRules = sqliteTable("resourceRules", {
     value: text("value").notNull()
 });
 
+export const supporterKey = sqliteTable("supporterKey", {
+    keyId: integer("keyId").primaryKey({ autoIncrement: true }),
+    key: text("key").notNull(),
+    githubUsername: text("githubUsername").notNull(),
+    phrase: text("phrase"),
+    tier: text("tier"),
+    valid: integer("valid", { mode: "boolean" }).notNull().default(false)
+});
+
 export type Org = InferSelectModel<typeof orgs>;
 export type User = InferSelectModel<typeof users>;
 export type Site = InferSelectModel<typeof sites>;
@@ -439,3 +448,4 @@ export type ResourceWhitelist = InferSelectModel<typeof resourceWhitelist>;
 export type VersionMigration = InferSelectModel<typeof versionMigrations>;
 export type ResourceRule = InferSelectModel<typeof resourceRules>;
 export type Domain = InferSelectModel<typeof domains>;
+export type SupporterKey = InferSelectModel<typeof supporterKey>;

server/lib/config.ts

@@ -10,6 +10,8 @@ import {
 } from "@server/lib/consts";
 import { passwordSchema } from "@server/auth/passwordSchema";
 import stoi from "./stoi";
+import db from "@server/db";
+import { SupporterKey, supporterKey } from "@server/db/schema";
 
 const portSchema = z.number().positive().gt(0).lte(65535);
 
@@ -155,6 +157,10 @@ const configSchema = z.object({
 export class Config {
     private rawConfig!: z.infer<typeof configSchema>;
 
+    supporterData: SupporterKey | null = null;
+
+    supporterHiddenUntil: number | null = null;
+
     constructor() {
         this.loadConfig();
     }
@@ -183,7 +189,9 @@ export class Config {
         }
 
         if (process.env.APP_BASE_DOMAIN) {
-            console.log("You're using deprecated environment variables. Transition to the configuration file. https://docs.fossorial.io/");
+            console.log(
+                "You're using deprecated environment variables. Transition to the configuration file. https://docs.fossorial.io/"
+            );
         }
 
         if (!environment) {
@@ -235,6 +243,17 @@ export class Config {
             : "false";
         process.env.DASHBOARD_URL = parsedConfig.data.app.dashboard_url;
 
+        try {
+            this.checkSupporterKey();
+        } catch (error) {
+            console.error("Error checking supporter key:", error);
+        }
+
+        if (this.supporterData) {
+            process.env.SUPPORTER_DATA = JSON.stringify(this.supporterData);
+            console.log("Thank you for being a supporter of Pangolin!");
+        }
+
         this.rawConfig = parsedConfig.data;
     }
 
@@ -251,6 +270,86 @@ export class Config {
     public getDomain(domainId: string) {
         return this.rawConfig.domains[domainId];
     }
+
+    public hideSupporterKey(days: number = 7) {
+        const now = new Date().getTime();
+
+        if (this.supporterHiddenUntil && now < this.supporterHiddenUntil) {
+            return;
+        }
+
+        this.supporterHiddenUntil = now + 1000 * 60 * 60 * 24 * days;
+    }
+
+    public isSupporterKeyHidden() {
+        const now = new Date().getTime();
+
+        if (this.supporterHiddenUntil && now < this.supporterHiddenUntil) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public async checkSupporterKey() {
+        const [key] = await db.select().from(supporterKey).limit(1);
+
+        if (!key) {
+            return;
+        }
+
+        const { key: licenseKey, githubUsername } = key;
+
+        const response = await fetch(
+            "https://api.dev.fossorial.io/api/v1/license/validate",
+            {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    licenseKey,
+                    githubUsername
+                })
+            }
+        );
+
+        if (!response.ok) {
+            this.supporterData = key;
+            return;
+        }
+
+        const data = await response.json();
+
+        if (!data.data.valid) {
+            this.supporterData = {
+                ...key,
+                valid: false
+            };
+            return;
+        }
+
+        this.supporterData = {
+            ...key,
+            valid: true
+        };
+
+        // update the supporter key in the database
+        await db.transaction(async (trx) => {
+            await trx.delete(supporterKey);
+            await trx.insert(supporterKey).values({
+                githubUsername,
+                key: licenseKey,
+                tier: data.data.tier || null,
+                phrase: data.data.cutePhrase || null,
+                valid: true
+            });
+        });
+    }
+
+    public getSupporterData() {
+        return this.supporterData;
+    }
 }
 
 export const config = new Config();

server/routers/external.ts

@@ -8,6 +8,7 @@ import * as target from "./target";
 import * as user from "./user";
 import * as auth from "./auth";
 import * as role from "./role";
+import * as supporterKey from "./supporterKey";
 import * as accessToken from "./accessToken";
 import HttpCode from "@server/types/HttpCode";
 import {
@@ -239,7 +240,6 @@ authenticated.delete(
     target.deleteTarget
 );
 
-
 authenticated.put(
     "/org/:orgId/role",
     verifyOrgAccess,
@@ -382,6 +382,9 @@ authenticated.get(
 
 authenticated.get(`/org/:orgId/overview`, verifyOrgAccess, org.getOrgOverview);
 
+authenticated.post(`/supporter-key/validate`, supporterKey.validateSupporterKey);
+authenticated.post(`/supporter-key/hide`, supporterKey.hideSupporterKey);
+
 unauthenticated.get("/resource/:resourceId/auth", resource.getResourceAuthInfo);
 
 // authenticated.get(

server/routers/internal.ts

@@ -4,8 +4,12 @@ import * as traefik from "@server/routers/traefik";
 import * as resource from "./resource";
 import * as badger from "./badger";
 import * as auth from "@server/routers/auth";
+import * as supporterKey from "@server/routers/supporterKey";
 import HttpCode from "@server/types/HttpCode";
-import { verifyResourceAccess, verifySessionUserMiddleware } from "@server/middlewares";
+import {
+    verifyResourceAccess,
+    verifySessionUserMiddleware
+} from "@server/middlewares";
 
 // Root routes
 const internalRouter = Router();
@@ -28,6 +32,11 @@ internalRouter.post(
     resource.getExchangeToken
 );
 
+internalRouter.get(
+    `/supporter-key/visible`,
+    supporterKey.isSupporterKeyVisible
+);
+
 // Gerbil routes
 const gerbilRouter = Router();
 internalRouter.use("/gerbil", gerbilRouter);

server/routers/supporterKey/hideSupporterKey.ts

@@ -0,0 +1,35 @@
+import { Request, Response, NextFunction } from "express";
+import HttpCode from "@server/types/HttpCode";
+import createHttpError from "http-errors";
+import logger from "@server/logger";
+import { response as sendResponse } from "@server/lib";
+import config from "@server/lib/config";
+
+export type HideSupporterKeyResponse = {
+    hidden: boolean;
+};
+
+export async function hideSupporterKey(
+    req: Request,
+    res: Response,
+    next: NextFunction
+): Promise<any> {
+    try {
+        config.hideSupporterKey();
+
+        return sendResponse<HideSupporterKeyResponse>(res, {
+            data: {
+                hidden: true
+            },
+            success: true,
+            error: false,
+            message: "Hidden",
+            status: HttpCode.OK
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(
+            createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred")
+        );
+    }
+}

server/routers/supporterKey/index.ts

@@ -0,0 +1,3 @@
+export * from "./validateSupporterKey";
+export * from "./isSupporterKeyVisible";
+export * from "./hideSupporterKey";

server/routers/supporterKey/isSupporterKeyVisible.ts

@@ -0,0 +1,54 @@
+import { Request, Response, NextFunction } from "express";
+import HttpCode from "@server/types/HttpCode";
+import createHttpError from "http-errors";
+import logger from "@server/logger";
+import { response as sendResponse } from "@server/lib";
+import config from "@server/lib/config";
+import db from "@server/db";
+import { count } from "drizzle-orm";
+import { users } from "@server/db/schema";
+
+export type IsSupporterKeyVisibleResponse = {
+    visible: boolean;
+};
+
+const USER_LIMIT = 5;
+
+export async function isSupporterKeyVisible(
+    req: Request,
+    res: Response,
+    next: NextFunction
+): Promise<any> {
+    try {
+        const hidden = config.isSupporterKeyHidden();
+        const key = config.getSupporterData();
+
+        let visible = !hidden && key?.valid !== true;
+
+        if (key?.tier === "Limited Supporter") {
+            const [numUsers] = await db.select({ count: count() }).from(users);
+
+            if (numUsers.count > USER_LIMIT) {
+                visible = true;
+            }
+        }
+
+        logger.debug(`Supporter key visible: ${visible}`);
+        logger.debug(JSON.stringify(key));
+
+        return sendResponse<IsSupporterKeyVisibleResponse>(res, {
+            data: {
+                visible
+            },
+            success: true,
+            error: false,
+            message: "Status",
+            status: HttpCode.OK
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(
+            createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred")
+        );
+    }
+}

server/routers/supporterKey/validateSupporterKey.ts

@@ -0,0 +1,115 @@
+import { Request, Response, NextFunction } from "express";
+import { z } from "zod";
+import HttpCode from "@server/types/HttpCode";
+import createHttpError from "http-errors";
+import logger from "@server/logger";
+import { fromError } from "zod-validation-error";
+import { response as sendResponse } from "@server/lib";
+import { suppressDeprecationWarnings } from "moment";
+import { supporterKey } from "@server/db/schema";
+import db from "@server/db";
+import { eq } from "drizzle-orm";
+import config from "@server/lib/config";
+
+const validateSupporterKeySchema = z
+    .object({
+        githubUsername: z.string().nonempty(),
+        key: z.string().nonempty()
+    })
+    .strict();
+
+export type ValidateSupporterKeyResponse = {
+    valid: boolean;
+    githubUsername?: string;
+    tier?: string;
+    phrase?: string;
+};
+
+export async function validateSupporterKey(
+    req: Request,
+    res: Response,
+    next: NextFunction
+): Promise<any> {
+    try {
+        const parsedBody = validateSupporterKeySchema.safeParse(req.body);
+        if (!parsedBody.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    fromError(parsedBody.error).toString()
+                )
+            );
+        }
+
+        const { githubUsername, key } = parsedBody.data;
+
+        const response = await fetch(
+            "https://api.dev.fossorial.io/api/v1/license/validate",
+            {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    licenseKey: key,
+                    githubUsername: githubUsername
+                })
+            }
+        );
+
+        if (!response.ok) {
+            logger.error(response);
+            return next(
+                createHttpError(
+                    HttpCode.INTERNAL_SERVER_ERROR,
+                    "An error occurred"
+                )
+            );
+        }
+
+        const data = await response.json();
+
+        if (!data || !data.data.valid) {
+            return sendResponse<ValidateSupporterKeyResponse>(res, {
+                data: {
+                    valid: false
+                },
+                success: true,
+                error: false,
+                message: "Invalid supporter key",
+                status: HttpCode.OK
+            });
+        }
+
+        await db.transaction(async (trx) => {
+            await trx.delete(supporterKey);
+            await trx.insert(supporterKey).values({
+                githubUsername: githubUsername,
+                key: key,
+                tier: data.data.tier || null,
+                phrase: data.data.cutePhrase || null,
+                valid: true
+            });
+        });
+
+        await config.checkSupporterKey();
+
+        return sendResponse<ValidateSupporterKeyResponse>(res, {
+            data: {
+                valid: true,
+                githubUsername: data.data.githubUsername,
+                tier: data.data.tier,
+                phrase: data.data.cutePhrase
+            },
+            success: true,
+            error: false,
+            message: "Valid supporter key",
+            status: HttpCode.OK
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(
+            createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred")
+        );
+    }
+}

server/setup/migrations.ts

@@ -17,6 +17,7 @@ import m8 from "./scripts/1.0.0-beta12";
 import m13 from "./scripts/1.0.0-beta13";
 import m15 from "./scripts/1.0.0-beta15";
 import m16 from "./scripts/1.0.0";
+import m17 from "./scripts/1.1.0";
 
 // THIS CANNOT IMPORT ANYTHING FROM THE SERVER
 // EXCEPT FOR THE DATABASE AND THE SCHEMA
@@ -33,7 +34,8 @@ const migrations = [
     { version: "1.0.0-beta.12", run: m8 },
     { version: "1.0.0-beta.13", run: m13 },
     { version: "1.0.0-beta.15", run: m15 },
-    { version: "1.0.0", run: m16 }
+    { version: "1.0.0", run: m16 },
+    { version: "1.1.0", run: m17 }
     // Add new migrations here as they are created
 ] as const;
 

server/setup/scripts/1.1.0.ts

@@ -0,0 +1,28 @@
+import db from "@server/db";
+import { sql } from "drizzle-orm";
+
+const version = "1.1.0";
+
+export default async function migration() {
+    console.log(`Running setup script ${version}...`);
+
+    try {
+        db.transaction((trx) => {
+            trx.run(sql`CREATE TABLE 'supporterKey' (
+	'keyId' integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	'key' text NOT NULL,
+	'githubUsername' text NOT NULL,
+	'phrase' text,
+	'tier' text,
+	'valid' integer DEFAULT false NOT NULL
+);`);
+        });
+
+        console.log(`Migrated database schema`);
+    } catch (e) {
+        console.log("Unable to migrate database schema");
+        throw e;
+    }
+
+    console.log(`${version} migration complete`);
+}