@stoker-platform/cli 0.5.12

package/lib/src/deploy/firestore-export/exportFirestoreData.js

@@ -0,0 +1,29 @@
+import { initializeFirebase, fetchCurrentSchema, runChildProcess } from "@stoker-platform/node-client";
+export const exportFirestoreData = async () => {
+    await initializeFirebase();
+    const schema = await fetchCurrentSchema();
+    const bucket = process.env.FB_FIRESTORE_EXPORT_BUCKET;
+    let collections = [];
+    for (let i = 0; i < Object.keys(schema.collections).length; i++) {
+        // eslint-disable-next-line security/detect-object-injection
+        collections.push(Object.keys(schema.collections)[i]);
+        if (i == Object.keys(schema.collections).length - 1 || collections.length == 100) {
+            console.log(`Exporting ${collections.length} collections...`);
+            try {
+                await runChildProcess("gcloud", [
+                    "firestore",
+                    "export",
+                    `gs://${bucket}/`,
+                    `--collection-ids=${collections.join(",")}`,
+                    `--project=${process.env.GCP_PROJECT}`,
+                    "--quiet",
+                ]);
+                collections = [];
+            }
+            catch {
+                throw new Error("Error exporting Firestore data.");
+            }
+        }
+    }
+    process.exit();
+};

package/lib/src/deploy/firestore-ttl/deployTTLs.js

@@ -0,0 +1,127 @@
+import { runChildProcess, initializeFirebase } from "@stoker-platform/node-client";
+import spawn from "cross-spawn";
+import { generateSchema } from "../schema/generateSchema.js";
+import { lintSchema } from "../../lint/lintSchema.js";
+export const deployTTLs = async () => {
+    const firebaseConfigString = process.env.STOKER_FB_WEB_APP_CONFIG;
+    if (!firebaseConfigString)
+        throw new Error("Firebase web app config not found.");
+    const firebaseConfig = JSON.parse(firebaseConfigString);
+    const projectId = firebaseConfig.projectId;
+    await initializeFirebase();
+    const currentSchema = await generateSchema();
+    await lintSchema(true);
+    const ttlsToAdd = [];
+    const ttlsToRemove = [];
+    const deployTTL = (collectionName, ttl) => {
+        return new Promise((resolve, reject) => {
+            return runChildProcess("gcloud", [
+                "firestore",
+                "fields",
+                "ttls",
+                "update",
+                ttl,
+                `--collection-group=${collectionName}`,
+                "--enable-ttl",
+                `--project=${projectId}`,
+                "--quiet",
+                "--async",
+            ])
+                .then(() => resolve())
+                .catch((error) => reject(error));
+        });
+    };
+    const removeTTL = (collectionName, ttl) => {
+        return new Promise((resolve, reject) => {
+            return runChildProcess("gcloud", [
+                "firestore",
+                "fields",
+                "ttls",
+                "update",
+                ttl,
+                `--collection-group=${collectionName}`,
+                "--disable-ttl",
+                `--project=${projectId}`,
+                "--quiet",
+                "--async",
+            ])
+                .then(() => resolve())
+                .catch((error) => reject(error));
+        });
+    };
+    const existingTTL = {};
+    const firestoreCollections = Object.values(currentSchema.collections)
+        .map((collection) => collection.labels.collection)
+        .concat("system_write_log");
+    for (const collection of firestoreCollections) {
+        const spawnPromise = new Promise((resolve, reject) => {
+            const childProcess = spawn("gcloud", [
+                "firestore",
+                "fields",
+                "ttls",
+                "list",
+                `--collection-group=${collection}`,
+                `--project=${projectId}`,
+            ]);
+            let stdout = "";
+            let stderr = "";
+            childProcess.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            childProcess.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            childProcess.on("close", (code) => {
+                if (code === 0) {
+                    resolve({ stdout, stderr });
+                }
+                else {
+                    reject(new Error(`Error retrieving ${collection} TTL`));
+                }
+            });
+        });
+        const { stdout, stderr } = await spawnPromise;
+        // eslint-disable-next-line security/detect-object-injection
+        existingTTL[collection] = stdout;
+        if (stderr) {
+            console.log(`Retrieve ${collection} TTL: ${stderr}`);
+        }
+    }
+    if (currentSchema.config.writeLogTTL) {
+        if (!existingTTL["system_write_log"].includes("system_write_log/fields/TTL")) {
+            ttlsToAdd.push(deployTTL("system_write_log", "TTL"));
+        }
+        else {
+            console.log(`TTL already exists for Write Log.\n`);
+        }
+    }
+    else if (existingTTL["system_write_log"]) {
+        ttlsToRemove.push(removeTTL("system_write_log", "TTL"));
+    }
+    Object.values(currentSchema.collections).forEach((collection) => {
+        const { labels, ttl } = collection;
+        const path = `databases/(default)/collectionGroups/${labels.collection}/fields/`;
+        if (ttl) {
+            if (!existingTTL[labels.collection].includes(`${path}${ttl}\n`)) {
+                ttlsToAdd.push(deployTTL(labels.collection, ttl));
+            }
+            else {
+                console.log(`TTL ${ttl} already exists for collection ${labels.collection}.\n`);
+            }
+            if (existingTTL[labels.collection].includes(path) && !existingTTL[labels.collection].includes(`${ttl}\n`)) {
+                ttlsToRemove.push(removeTTL(labels.collection, existingTTL[labels.collection].split(path)[1].split("\n")[0]));
+            }
+        }
+        else if (existingTTL[labels.collection]) {
+            ttlsToRemove.push(removeTTL(labels.collection, existingTTL[labels.collection].split(path)[1].split("\n")[0]));
+        }
+    });
+    try {
+        await Promise.all(ttlsToRemove);
+        await Promise.all(ttlsToAdd);
+        process.exit();
+    }
+    catch (error) {
+        throw new Error("Error deploying TTLs", { cause: error });
+    }
+};

package/lib/src/deploy/live-update/liveUpdate.js

@@ -0,0 +1,22 @@
+import { fetchCurrentSchema, initializeFirebase } from "@stoker-platform/node-client";
+import { getFirestore, FieldValue } from "firebase-admin/firestore";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const liveUpdate = async (options) => {
+    await initializeFirebase();
+    const db = getFirestore();
+    const batch = db.batch();
+    const currentSchema = await fetchCurrentSchema();
+    const deployId = db.collection("system_deployment").doc("latest_deploy").collection("deploy_history").doc().id;
+    const versionInfo = {
+        version: currentSchema.version,
+        force: options.secure || false,
+        refresh: options.refresh || false,
+        time: FieldValue.serverTimestamp(),
+        payload: options.payload || {},
+    };
+    batch.set(db.collection("system_deployment").doc("latest_deploy"), versionInfo);
+    batch.set(db.collection("system_deployment").doc("latest_deploy").collection("deploy_history").doc(deployId), versionInfo);
+    await batch.commit();
+    console.info("LIVE UPDATE TRIGGERED");
+    process.exit();
+};

package/lib/src/deploy/maintenance/activateMaintenanceMode.js

@@ -0,0 +1,9 @@
+import { initializeFirebase } from "@stoker-platform/node-client";
+import { getFirestore } from "firebase-admin/firestore";
+export const activateMaintenanceMode = async () => {
+    await initializeFirebase();
+    const db = getFirestore();
+    await db.collection("system_deployment").doc("maintenance_mode").set({ active: true });
+    console.info("MAINTENANCE MODE ENGAGED");
+    process.exit();
+};

package/lib/src/deploy/maintenance/disableMaintenanceMode.js

@@ -0,0 +1,9 @@
+import { initializeFirebase } from "@stoker-platform/node-client";
+import { getFirestore } from "firebase-admin/firestore";
+export const disableMaintenanceMode = async () => {
+    await initializeFirebase();
+    const db = getFirestore();
+    await db.collection("system_deployment").doc("maintenance_mode").set({ active: false });
+    console.info("MAINTENANCE MODE DISENGAGED");
+    process.exit();
+};

package/lib/src/deploy/maintenance/setDeploymentStatus.js

@@ -0,0 +1,22 @@
+import { initializeFirebase } from "@stoker-platform/node-client";
+import { getFirestore } from "firebase-admin/firestore";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const setDeploymentStatus = async (status) => {
+    await initializeFirebase();
+    const db = getFirestore();
+    if (!["idle", "in_progress"].includes(status)) {
+        throw new Error("Invalid deployment status");
+    }
+    await db.runTransaction(async (transaction) => {
+        if (status === "in_progress") {
+            const deploymentStatus = await transaction.get(db.collection("system_deployment").doc("status"));
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            if (deploymentStatus.exists && deploymentStatus.data().status === "in_progress") {
+                throw new Error("Deployment already in progress. Please try again later.");
+            }
+        }
+        transaction.set(db.collection("system_deployment").doc("status"), { status });
+    });
+    console.info(`DEPLOYMENT STATUS SET TO ${status.toUpperCase()}\n`);
+    return;
+};

package/lib/src/deploy/rules-indexes/generateFirestoreIndexes.js

@@ -0,0 +1,23 @@
+import { generateSchema } from "../schema/generateSchema.js";
+import { lintSchema } from "../../lint/lintSchema.js";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { writeFileSync } from "fs";
+export const generateFirestoreIndexes = async () => {
+    if (!process.env.URL_FIRESTORE_INDEXES) {
+        throw new Error("STOKER_FIRESTORE_INDEXES_URL is not set");
+    }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const schema = await generateSchema();
+    await lintSchema(true);
+    const indexesResponse = await fetch(process.env.URL_FIRESTORE_INDEXES, {
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ schema }),
+        method: "POST",
+    });
+    const indexes = await indexesResponse.json();
+    writeFileSync(resolve(__dirname, process.cwd(), "firebase-rules", "firestore.indexes.json"), JSON.stringify(indexes, null, 4));
+};

package/lib/src/deploy/rules-indexes/generateFirestoreRules.js

@@ -0,0 +1,35 @@
+import { generateSchema } from "../schema/generateSchema.js";
+import { lintSchema } from "../../lint/lintSchema.js";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { readFileSync, writeFileSync } from "fs";
+export const generateFirestoreRules = async () => {
+    if (!process.env.URL_FIRESTORE_RULES) {
+        throw new Error("STOKER_FIRESTORE_RULES_URL is not set");
+    }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const schema = await generateSchema();
+    await lintSchema(true);
+    const rulesResponse = await fetch(process.env.URL_FIRESTORE_RULES, {
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ schema }),
+        method: "POST",
+    });
+    let rules = await rulesResponse.text();
+    const customRules = readFileSync(resolve(__dirname, process.cwd(), "firebase-rules", "firestore.custom.rules"), "utf8");
+    const trimLastTwoBraces = (input) => {
+        let trimmed = input.trimEnd();
+        let numTrimmed = 0;
+        while (numTrimmed < 2 && trimmed.endsWith("}")) {
+            trimmed = trimmed.slice(0, -1).trimEnd();
+            numTrimmed++;
+        }
+        return trimmed;
+    };
+    rules = trimLastTwoBraces(rules);
+    rules = `${rules}\n\n        // CUSTOM SECURITY RULES\n\n        ${customRules.split("\n").join("\n        ")}\n    }\n}`;
+    writeFileSync(resolve(__dirname, process.cwd(), "firebase-rules", "firestore.rules"), rules);
+};

package/lib/src/deploy/rules-indexes/generateStorageRules.js

@@ -0,0 +1,23 @@
+import { generateSchema } from "../schema/generateSchema.js";
+import { lintSchema } from "../../lint/lintSchema.js";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+import { writeFileSync } from "fs";
+export const generateStorageRules = async () => {
+    if (!process.env.URL_STORAGE_RULES) {
+        throw new Error("STOKER_STORAGE_RULES_URL is not set");
+    }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const schema = await generateSchema();
+    await lintSchema(true);
+    const rulesResponse = await fetch(process.env.URL_STORAGE_RULES, {
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ schema }),
+        method: "POST",
+    });
+    const rules = await rulesResponse.text();
+    writeFileSync(resolve(__dirname, process.cwd(), "firebase-rules", "storage.rules"), rules);
+};

package/lib/src/deploy/schema/generateSchema.js

@@ -0,0 +1,184 @@
+import { tryPromise } from "@stoker-platform/node-client";
+import { getRelationLists, roleHasOperationAccess } from "@stoker-platform/utils";
+import { ServerValue } from "firebase-admin/database";
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { pathToFileURL } from "url";
+export const generateSchema = async (includeComputedFields = false) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const newSchema = {};
+    const path = join(process.cwd(), "lib", "main.js");
+    const url = pathToFileURL(path).href;
+    const globalConfigFile = await import(url);
+    const globalConfig = globalConfigFile.default("node");
+    const projectData = await readFile(join(process.cwd(), "project-data.json"), "utf8");
+    const projectDataJson = JSON.parse(projectData);
+    const version = projectDataJson.version || 1;
+    newSchema.version = version;
+    newSchema.published_time = ServerValue.TIMESTAMP;
+    const collections = await readdir(join(process.cwd(), "lib", "collections"));
+    const { roles, firebase } = globalConfig;
+    const configSchema = {
+        roles,
+        permissionsIndexExemption: false,
+    };
+    if (firebase?.permissionsIndexExemption)
+        configSchema.permissionsIndexExemption = true;
+    firebase?.writeLogIndexExemption
+        ? (configSchema.writeLogIndexExemption = firebase?.writeLogIndexExemption || [])
+        : null;
+    firebase?.writeLogTTL ? (configSchema.writeLogTTL = firebase?.writeLogTTL) : null;
+    newSchema.config = configSchema;
+    const fullSchema = [];
+    for (const collection of collections) {
+        if (globalConfig.disabledCollections?.includes(collection))
+            continue;
+        const path = join(process.cwd(), "lib", "collections", collection);
+        const url = pathToFileURL(path).href;
+        const schema = await import(url);
+        fullSchema.push(schema.default("node"));
+    }
+    newSchema.collections = {};
+    for (const collection of collections) {
+        if (globalConfig.disabledCollections?.includes(collection))
+            continue;
+        const path = join(process.cwd(), "lib", "collections", collection);
+        const url = pathToFileURL(path).href;
+        const schema = await import(url);
+        const persistSchema = schema.default("node");
+        const { labels, access, preloadCache, admin } = persistSchema;
+        const { serverReadOnly } = access;
+        if (!includeComputedFields) {
+            persistSchema.fields = persistSchema.fields.filter((field) => field.type !== "Computed");
+        }
+        else {
+            for (const field of persistSchema.fields) {
+                if (field.type === "Computed") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    delete field.formula;
+                }
+            }
+        }
+        if (admin) {
+            const filters = ((await tryPromise(admin.filters)) || []);
+            const cards = (await tryPromise(admin.cards));
+            const calendar = (await tryPromise(admin.calendar));
+            const statusField = (await tryPromise(admin.statusField));
+            const readRoles = roles.filter((role) => roleHasOperationAccess(persistSchema, role, "read"));
+            const nonStandardRoles = (serverReadOnly || []).concat(preloadCache?.roles || []);
+            const standardRoles = readRoles.filter((role) => !nonStandardRoles.includes(role));
+            const noPreloadCacheRoles = readRoles.filter((role) => !preloadCache?.roles.includes(role));
+            const addUnscheduledRoles = calendar?.unscheduled?.roles && !noPreloadCacheRoles.length;
+            if (calendar?.unscheduled) {
+                filters.push({
+                    type: "select",
+                    field: calendar.startField,
+                    roles: calendar?.unscheduled.roles,
+                });
+            }
+            const relationListFields = getRelationLists(labels.collection, fullSchema);
+            if (relationListFields.size > 0) {
+                for (const relationListField of relationListFields.values()) {
+                    const existingRelationFilter = filters.find((filter) => filter.type === "relation" && filter.field === relationListField.field);
+                    if (existingRelationFilter && existingRelationFilter.type === "relation") {
+                        if (existingRelationFilter.roles) {
+                            const newRoles = new Set(existingRelationFilter.roles);
+                            for (const role of relationListField.roles || noPreloadCacheRoles) {
+                                if (noPreloadCacheRoles.includes(role)) {
+                                    newRoles.add(role);
+                                }
+                            }
+                            existingRelationFilter.roles = Array.from(newRoles);
+                        }
+                    }
+                    else {
+                        filters.push({
+                            type: "relation",
+                            field: relationListField.field,
+                            roles: relationListField.roles?.filter((role) => noPreloadCacheRoles.includes(role)) ||
+                                noPreloadCacheRoles,
+                        });
+                    }
+                }
+            }
+            if (statusField || cards?.statusField) {
+                const existingStatusFieldIndex = filters.findIndex((filter) => "field" in filter && filter.field === (statusField?.field || cards?.statusField));
+                const newFilter = {
+                    type: "status",
+                };
+                if (addUnscheduledRoles) {
+                    newFilter.roles = calendar?.unscheduled?.roles;
+                }
+                filters.push(newFilter);
+                if (existingStatusFieldIndex !== -1) {
+                    filters.splice(existingStatusFieldIndex, 1);
+                }
+            }
+            if (calendar) {
+                const existingRangeIndex = filters.findIndex((filter) => filter.type === "range");
+                if (existingRangeIndex === -1) {
+                    if (noPreloadCacheRoles.length) {
+                        filters.push({
+                            type: "range",
+                            field: calendar.startField,
+                        });
+                    }
+                }
+                else {
+                    if (noPreloadCacheRoles.length === 0) {
+                        filters.splice(existingRangeIndex, 1);
+                    }
+                }
+            }
+            if ((cards || admin.images) && standardRoles.length) {
+                filters.push({
+                    type: "select",
+                    field: "Last_Save_At",
+                    roles: standardRoles,
+                });
+            }
+            const persistFilters = [];
+            filters.forEach((filter) => {
+                const persistFilter = {};
+                if (filter.type === "status") {
+                    if (statusField || cards?.statusField) {
+                        const field = statusField?.field || cards?.statusField;
+                        if (field) {
+                            persistFilter.field = field;
+                        }
+                    }
+                }
+                else {
+                    persistFilter.field = filter.field;
+                }
+                if ("roles" in filter && filter.roles?.length) {
+                    persistFilter.roles = filter.roles;
+                }
+                if (addUnscheduledRoles) {
+                    if (persistFilter.roles?.length) {
+                        persistFilter.roles = persistFilter.roles?.filter((role) => calendar.unscheduled?.roles?.includes(role));
+                    }
+                    else {
+                        persistFilter.roles = calendar.unscheduled?.roles;
+                    }
+                }
+                if (filter.type === "range") {
+                    persistFilter.range = true;
+                }
+                if (filter.type !== "status" && filter.field === "Last_Save_At" && filter.type === "select") {
+                    persistFilter.standalone = true;
+                }
+                persistFilters.push(persistFilter);
+            });
+            persistSchema.queries = persistFilters;
+        }
+        delete persistSchema.custom;
+        delete persistSchema.admin;
+        for (const field of persistSchema.fields) {
+            delete field.custom;
+            delete field.admin;
+        }
+        newSchema.collections[collection.split(".")[0]] = persistSchema;
+    }
+    return newSchema;
+};

package/lib/src/deploy/schema/persistSchema.js

@@ -0,0 +1,14 @@
+import { getDatabase } from "firebase-admin/database";
+import { initializeFirebase } from "@stoker-platform/node-client";
+import { generateSchema } from "./generateSchema.js";
+import { lintSchema } from "../../lint/lintSchema.js";
+export const persistSchema = async () => {
+    await initializeFirebase();
+    const rtdb = getDatabase();
+    const ref = rtdb.ref("schema");
+    const schema = await generateSchema(true);
+    await lintSchema(true);
+    await ref.push(schema);
+    console.info("Schema persisted successfully.");
+    process.exit();
+};