@stoker-platform/cli 0.5.12

package/init-files/src/utils.ts

@@ -0,0 +1,3 @@
+export const blueField = "bg-blue-500 dark:bg-blue-500/50 w-7 h-7 p-1.5 rounded-md text-white"
+export const redField = "bg-destructive w-7 h-7 p-1.5 rounded-md text-white"
+export const greenField = "bg-green-500 dark:bg-green-500/50 w-7 h-7 p-1.5 rounded-md text-white"

package/init-files/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/init-files/test/test.ts

@@ -0,0 +1,5 @@
+import { expect, test } from "vitest"
+
+test("sample test", async () => {
+    expect(true).toBe(true)
+})

package/init-files/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "useDefineForClassFields": true,
+        "module": "ESNext",
+        "lib": ["ESNext", "DOM"],
+        "moduleResolution": "Node",
+        "strict": true,
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "esModuleInterop": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitReturns": true,
+        "skipLibCheck": true,
+        "outDir": "lib",
+
+        "jsx": "react-jsx"
+    },
+    "include": ["src"],
+    "files": ["src/vite-env.d.ts"],
+    "exclude": ["test", "vitest.config.ts"]
+}

package/init-files/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+    test: {
+        environment: "node",
+        globals: true,
+        include: ["test/**/*"],
+    },
+})

package/lib/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@stoker-platform/cli",
+    "version": "0.5.11",
+    "type": "module",
+    "license": "SEE LICENSE IN LICENSE.md",
+    "main": "./lib/src/main.js",
+    "files": [
+        "lib",
+        "init-files",
+        "LICENSE.md"
+    ],
+    "scripts": {
+        "dev": "tsc --watch --preserveWatchOutput",
+        "lint": "tsc && eslint .",
+        "build": "tsc --build",
+        "test": "echo \"Error: no test specified\""
+    },
+    "bin": {
+        "stoker": "./lib/src/main.js"
+    },
+    "dependencies": {
+        "@faker-js/faker": "^10.1.0",
+        "@google-cloud/bigquery": "^8.1.1",
+        "@google-cloud/secret-manager": "^6.1.1",
+        "@google-cloud/storage": "^7.18.0",
+        "@inquirer/prompts": "^8.1.0",
+        "@stoker-platform/node-client": "0.5.8",
+        "@stoker-platform/types": "0.5.4",
+        "@stoker-platform/utils": "0.5.5",
+        "algoliasearch": "^5.46.2",
+        "commander": "^14.0.0",
+        "cross-spawn": "^7.0.6",
+        "dotenv": "^17.2.3",
+        "firebase-admin": "^13.6.0"
+    },
+    "devDependencies": {
+        "@types/cross-spawn": "^6.0.6",
+        "eslint-config-custom": "*",
+        "tsconfig": "*"
+    },
+    "engines": {
+        "node": ">=22",
+        "npm": "11"
+    }
+}

package/lib/src/data/exportToBigQuery.js

@@ -0,0 +1,41 @@
+import { BigQuery } from "@google-cloud/bigquery";
+import { Storage } from "@google-cloud/storage";
+import { initializeFirebase } from "@stoker-platform/node-client";
+import { getApp } from "firebase-admin/app";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const exportToBigQuery = async (options) => {
+    await initializeFirebase();
+    const app = getApp();
+    const bigqueryClient = new BigQuery({ projectId: app.options.projectId });
+    const storage = new Storage({ projectId: app.options.projectId });
+    const collection = options.collection;
+    // GET LATEST COLLECTION FILE
+    const bucket = `gs://${process.env.FB_FIRESTORE_EXPORT_BUCKET}`;
+    const [files] = await storage.bucket(bucket).getFiles();
+    const collectionFiles = files.filter((file) => file.name.includes(`all_namespaces_kind_${collection}.export_metadata`));
+    if (!collectionFiles.length) {
+        console.log(`No files for collection ${collection} found in Cloud Storage bucket.`);
+        process.exit();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const { name: latestFile } = collectionFiles.at(-1);
+    // CREATE BIGQUERY DATASET
+    const [datasets] = await bigqueryClient.getDatasets();
+    datasets.filter((dataset) => dataset.id === collection);
+    if (!datasets.length) {
+        const options = { location: process.env.FB_FIRESTORE_REGION };
+        const [dataset] = await bigqueryClient.createDataset(collection, options);
+        console.log(`Dataset ${dataset.id} created.`);
+    }
+    // EXPORT COLLECTION TO BIGQUERY
+    const datetime = new Date().toISOString().split(".")[0].replaceAll(":", "-");
+    const jobConfig = { sourceFormat: "DATASTORE_BACKUP" };
+    if (options.fields)
+        jobConfig.projectionFields = options.fields.split(",");
+    const [job] = await bigqueryClient
+        .dataset(collection, { location: process.env.FB_FIRESTORE_REGION })
+        .table(datetime)
+        .load(storage.bucket(bucket).file(latestFile), jobConfig);
+    console.log(`Job ${job.id} completed.`);
+    process.exit();
+};

package/lib/src/data/seedData.js

@@ -0,0 +1,347 @@
+import { initializeStoker, addRecord, updateRecord, fetchCurrentSchema } from "@stoker-platform/node-client";
+import { join } from "node:path";
+import { faker } from "@faker-js/faker";
+import { Timestamp } from "firebase-admin/firestore";
+import { getField, getFieldCustomization, isRelationField, tryPromise } from "@stoker-platform/utils";
+/* eslint-disable security/detect-object-injection */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const seedData = async (options) => {
+    const records = parseInt(options.number);
+    const relationRecords = parseInt(options.relations);
+    const sucollectionRecords = parseInt(options.sucollections);
+    const delay = parseInt(options.delay);
+    if (isNaN(records)) {
+        throw new Error("Number of records must be a valid number");
+    }
+    if (options.relationRecords && isNaN(relationRecords)) {
+        throw new Error("Number of relations must be a valid number");
+    }
+    if (options.sucollectionRecords && isNaN(sucollectionRecords)) {
+        throw new Error("Number of subcollections must be a valid number");
+    }
+    if (options.delay && isNaN(parseInt(options))) {
+        throw new Error("Delay must be a valid number");
+    }
+    const { getCustomizationFile } = await initializeStoker(options.mode || "development", options.tenant, join(process.cwd(), "lib", "main.js"), join(process.cwd(), "lib", "collections"));
+    const schema = await fetchCurrentSchema();
+    const collections = options.collections || Object.keys(schema.collections);
+    const orderedCollections = collections.sort((a, b) => {
+        const schemaA = schema.collections[a];
+        const schemaB = schema.collections[b];
+        const seedOrderA = schemaA.seedOrder || Number.MAX_SAFE_INTEGER;
+        const seedOrderB = schemaB.seedOrder || Number.MAX_SAFE_INTEGER;
+        return seedOrderA - seedOrderB;
+    });
+    if (relationRecords > records) {
+        throw new Error("Relations records must be less than records");
+    }
+    if (sucollectionRecords > records) {
+        throw new Error("Subcollections records must be less than records");
+    }
+    const data = {};
+    const numbers = {};
+    const unique = {};
+    const twoWayProcessed = {};
+    const fieldCount = {};
+    const seedField = async (record, field, collection) => {
+        const customizationFile = getCustomizationFile(collection.labels.collection, schema);
+        const fieldCustomization = getFieldCustomization(field, customizationFile);
+        const { labels, auth } = collection;
+        switch (field.type) {
+            case "String": {
+                const getStringValue = () => {
+                    if (auth && field.name === "Name") {
+                        record[field.name] = faker.person.fullName();
+                    }
+                    else if (field.values) {
+                        record[field.name] = field.values[Math.floor(Math.random() * field.values.length)];
+                    }
+                    else if (field.uuid) {
+                        record[field.name] = faker.string.uuid();
+                    }
+                    else if (field.email) {
+                        record[field.name] = faker.internet.email();
+                    }
+                    else if (field.ip) {
+                        record[field.name] = faker.internet.ip();
+                    }
+                    else if (field.url) {
+                        record[field.name] = faker.image.url({
+                            width: Math.floor(Math.random() * (500 - 25 + 1)) + 25,
+                            height: Math.floor(Math.random() * (500 - 25 + 1)) + 25,
+                        });
+                    }
+                    else if (field.emoji) {
+                        record[field.name] = faker.internet.emoji();
+                    }
+                    else if (field.pattern) {
+                        const generatedValue = faker.helpers.fromRegExp(field.pattern);
+                        record[field.name] = generatedValue.split("\\").join("").slice(1, -1);
+                    }
+                    else {
+                        const minLength = field.minlength || 5;
+                        const maxLength = field.maxlength || 500;
+                        const length = field.length || Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength;
+                        record[field.name] = faker.string.alpha({ length });
+                    }
+                };
+                getStringValue();
+                if (field.unique) {
+                    unique[labels.collection][field.name] ||= [];
+                    while (unique[labels.collection][field.name].includes(record[field.name])) {
+                        getStringValue();
+                    }
+                    unique[labels.collection][field.name].push(record[field.name]);
+                }
+                break;
+            }
+            case "Number": {
+                const getNumberValue = () => {
+                    if (field.autoIncrement) {
+                        numbers[labels.collection][field.name] ||= 0;
+                        numbers[labels.collection][field.name]++;
+                        record[field.name] = numbers[labels.collection][field.name];
+                    }
+                    else if (field.values) {
+                        record[field.name] = field.values[Math.floor(Math.random() * field.values.length)];
+                    }
+                    else if (field.decimal) {
+                        record[field.name] = faker.number.float({
+                            fractionDigits: field.decimal || 2,
+                            min: field.min || 0,
+                            max: field.max || 1000,
+                        });
+                    }
+                    else {
+                        record[field.name] = faker.number.int({
+                            min: field.min || 0,
+                            max: field.max || 1000,
+                        });
+                    }
+                };
+                getNumberValue();
+                if (field.unique) {
+                    unique[labels.collection][field.name] ||= [];
+                    while (unique[labels.collection][field.name].includes(record[field.name])) {
+                        getNumberValue();
+                    }
+                    unique[labels.collection][field.name].push(record[field.name]);
+                }
+                break;
+            }
+            case "Boolean":
+                record[field.name] = faker.datatype.boolean();
+                break;
+            case "Timestamp": {
+                if (collection.ttl === field.name) {
+                    record[field.name] = Timestamp.fromDate(new Date(Date.now() + 1000 * 60 * 60 * 24 * 30));
+                }
+                else {
+                    const minDate = field.min ? new Date(field.min) : new Date(0);
+                    const maxDate = field.max ? new Date(field.max) : new Date();
+                    const randomDate = new Date(minDate.getTime() + Math.random() * (maxDate.getTime() - minDate.getTime()));
+                    record[field.name] = Timestamp.fromDate(randomDate);
+                }
+                break;
+            }
+            case "Array": {
+                const isLocation = await tryPromise(fieldCustomization.admin?.location);
+                if (isLocation) {
+                    record[field.name] = [faker.location.latitude(), faker.location.longitude()];
+                }
+                else {
+                    if (field.values) {
+                        const arrayLength = field.length ||
+                            Math.floor(Math.random() * ((field.maxlength || 10) - (field.minlength || 1) + 1)) +
+                                (field.minlength || 1);
+                        record[field.name] = Array.from({ length: arrayLength }, () => 
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        faker.helpers.arrayElement(field.values));
+                    }
+                    else {
+                        const arrayLength = field.length ||
+                            Math.floor(Math.random() * ((field.maxlength || 10) - (field.minlength || 1) + 1)) +
+                                (field.minlength || 1);
+                        record[field.name] = Array.from({ length: arrayLength }, () => {
+                            const elementLength = Math.min(Math.floor(Math.random() * 10) + 1, field.maxlength || 10);
+                            return faker.string.alpha({ length: elementLength });
+                        });
+                    }
+                }
+                break;
+            }
+            case "Map": {
+                const isRichText = await tryPromise(fieldCustomization.admin?.richText);
+                record[field.name] = {};
+                if (!isRichText) {
+                    const numKeys = Math.floor(Math.random() * 100) + 1;
+                    for (let j = 0; j < numKeys; j++) {
+                        const key = faker.string.alpha({ length: Math.floor(Math.random() * 10) + 1 });
+                        record[field.name][key] = faker.string.alpha({ length: Math.floor(Math.random() * 10) + 1 });
+                    }
+                }
+                else {
+                    record[field.name] = {
+                        ops: [
+                            {
+                                insert: "Test\n",
+                            },
+                        ],
+                    };
+                }
+                break;
+            }
+        }
+    };
+    const getRelation = (field, record, collection) => {
+        if (isRelationField(field)) {
+            const relationCollection = schema.collections[field.collection];
+            const { parentCollection, singleton } = relationCollection;
+            if (parentCollection || singleton)
+                return;
+            const count = fieldCount[collection.labels.collection][field.name];
+            const relationField = {};
+            let numberOfRelations = 1;
+            if (["ManyToOne", "ManyToMany"].includes(field.type)) {
+                if (field.length) {
+                    numberOfRelations = field.length;
+                }
+                else {
+                    const min = field.min || 1;
+                    const max = relationRecords || field.max || 5;
+                    numberOfRelations = Math.floor(Math.random() * (max - min + 1)) + min;
+                }
+            }
+            for (let i = 0; i < numberOfRelations; i++) {
+                let relationRecord;
+                if (field.enforceHierarchy) {
+                    const enforceHierarchy = field.enforceHierarchy;
+                    const parentField = getField(collection.fields, field.enforceHierarchy.field);
+                    const options = [];
+                    for (const parentRecord of data[field.collection]) {
+                        if (Object.keys(record[parentField.name]).every((parentRelation) => Object.keys(parentRecord[enforceHierarchy.recordLinkField]).includes(parentRelation))) {
+                            options.push(parentRecord);
+                        }
+                    }
+                    const index = Math.floor(Math.random() * options.length);
+                    relationRecord = options[index];
+                }
+                else {
+                    if (!data[field.collection]) {
+                        throw new Error(`Collection ${field.collection} has not had any records added yet. Try changing the seed order of the collection.`);
+                    }
+                    relationRecord = data[field.collection][count];
+                }
+                if (relationRecord) {
+                    fieldCount[collection.labels.collection][field.name]++;
+                    if (fieldCount[collection.labels.collection][field.name] === records) {
+                        fieldCount[collection.labels.collection][field.name] = 0;
+                    }
+                    relationField[relationRecord.id] = {
+                        Collection_Path: relationRecord.Collection_Path,
+                    };
+                    if (field.includeFields) {
+                        for (const includeField of field.includeFields) {
+                            relationField[relationRecord.id][includeField] = relationRecord[includeField];
+                        }
+                    }
+                    if (field.twoWay) {
+                        relationRecord[field.twoWay] = {
+                            [record.id]: {
+                                Collection_Path: record.Collection_Path,
+                            },
+                        };
+                    }
+                }
+            }
+            return relationField;
+        }
+        return;
+    };
+    for (const collection of orderedCollections) {
+        const collectionSchema = schema.collections[collection];
+        const { auth, fields, parentCollection, singleton, softDelete } = collectionSchema;
+        if (parentCollection || singleton)
+            continue;
+        data[collection] = [];
+        numbers[collection] = {};
+        unique[collection] = {};
+        twoWayProcessed[collection] ||= [];
+        fieldCount[collection] ||= {};
+        for (let i = 0; i < records; i++) {
+            const record = {};
+            for (const field of fields) {
+                if (field.type === "Embedding")
+                    continue;
+                if (softDelete?.timestampField === field.name)
+                    continue;
+                if (softDelete?.archivedField === field.name) {
+                    record[field.name] = false;
+                    continue;
+                }
+                if (field.restrictCreate === true)
+                    continue;
+                if (!isRelationField(field) && !(auth && field.name === "User_ID")) {
+                    await seedField(record, field, collectionSchema);
+                }
+                else if (isRelationField(field) &&
+                    (field.required || field.min) &&
+                    !(field.twoWay && (twoWayProcessed[collection].includes(field.name) || field.type === "ManyToOne"))) {
+                    fieldCount[collection][field.name] ||= 0;
+                    const relation = getRelation(field, record, collectionSchema);
+                    if (relation) {
+                        record[field.name] = relation;
+                    }
+                }
+            }
+            if (delay) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            const result = await addRecord([collection], record);
+            data[collection].push(result);
+            console.log(`Added record ${result.id} to collection ${collection}`);
+        }
+        for (const field of fields) {
+            if (isRelationField(field) && field.twoWay && field.required) {
+                twoWayProcessed[field.collection] ||= [];
+                twoWayProcessed[field.collection].push(field.twoWay);
+            }
+        }
+    }
+    for (const collection of orderedCollections) {
+        const collectionSchema = schema.collections[collection];
+        const { fields, parentCollection, singleton } = collectionSchema;
+        if (parentCollection || singleton)
+            continue;
+        for (const record of data[collection]) {
+            const updatedRecord = {};
+            for (const field of fields) {
+                if (field.restrictUpdate === true)
+                    continue;
+                if (isRelationField(field) &&
+                    (field.required || field.min) &&
+                    !(field.twoWay && (twoWayProcessed[collection].includes(field.name) || field.type === "ManyToOne"))) {
+                    fieldCount[collection][field.name] ||= 0;
+                    const relation = getRelation(field, record, collectionSchema);
+                    if (relation) {
+                        updatedRecord[field.name] = relation;
+                    }
+                }
+            }
+            if (delay) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            const result = await updateRecord([collection], record.id, updatedRecord);
+            const index = data[collection].findIndex((r) => r.id === result.id);
+            data[collection] = data[collection].with(index, result);
+            console.log(`Added relations to record ${result.id} in collection ${collection}`);
+        }
+        for (const field of fields) {
+            if (isRelationField(field) && field.twoWay && !field.required) {
+                twoWayProcessed[field.collection] ||= [];
+                twoWayProcessed[field.collection].push(field.twoWay);
+            }
+        }
+    }
+    process.exit();
+};

package/lib/src/deploy/applySchema.js

@@ -0,0 +1,43 @@
+import { runChildProcess } from "@stoker-platform/node-client";
+import { getFunctionsData } from "./cloud-functions/getFunctionsData.js";
+import { generateSchema } from "./schema/generateSchema.js";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const applySchema = async () => {
+    try {
+        await runChildProcess("npm", ["run", "format"]);
+        await runChildProcess("npm", ["run", "lint"]);
+        await runChildProcess("npm", ["run", "build"]);
+        await runChildProcess("npm", ["run", "test"]);
+        await runChildProcess("npx", ["stoker", "lint-schema"]);
+        await runChildProcess("npx", ["stoker", "security-report"]);
+        await runChildProcess("npx", ["stoker", "generate-firestore-rules"]);
+        await runChildProcess("npx", ["stoker", "generate-storage-rules"]);
+        const schema = await generateSchema(true);
+        const emulatorExportDir = join(process.cwd(), "firebase-emulator-data", "database_export");
+        const exportFiles = await readdir(emulatorExportDir);
+        const targetFile = exportFiles[0];
+        if (!targetFile)
+            throw new Error("No emulator RTDB export file found in database_export directory");
+        const targetPath = join(emulatorExportDir, targetFile);
+        let emulatorData = {};
+        try {
+            // eslint-disable-next-line security/detect-non-literal-fs-filename
+            const currentContent = await readFile(targetPath, "utf8");
+            emulatorData = JSON.parse(currentContent);
+        }
+        catch {
+            emulatorData = {};
+        }
+        schema.published_time = Date.now();
+        emulatorData.schema = { "1": schema };
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        await writeFile(targetPath, JSON.stringify(emulatorData, null, 4));
+        await getFunctionsData();
+        process.exit();
+    }
+    catch (error) {
+        throw new Error("Error applying schema.", { cause: error });
+    }
+};

package/lib/src/deploy/cloud-functions/getFunctionsData.js

@@ -0,0 +1,18 @@
+import { initializeFirebase, tryPromise } from "@stoker-platform/node-client";
+import { writeFileSync } from "fs";
+import { generateSchema } from "../schema/generateSchema.js";
+import { join } from "path";
+import { pathToFileURL } from "url";
+export const getFunctionsData = async () => {
+    await initializeFirebase();
+    const path = join(process.cwd(), "lib", "main.js");
+    const url = pathToFileURL(path).href;
+    const globalConfigFile = await import(/* @vite-ignore */ url);
+    const config = globalConfigFile.default;
+    const globalConfig = config("node");
+    const timezone = await tryPromise(globalConfig.timezone);
+    const schema = await generateSchema();
+    const filePath = join(process.cwd(), "functions", "project-data.json");
+    writeFileSync(filePath, JSON.stringify({ timezone, schema }, null, 2));
+    return;
+};

package/lib/src/deploy/deployProject.js

@@ -0,0 +1,116 @@
+import { fetchCurrentSchema, initializeFirebase, runChildProcess } from "@stoker-platform/node-client";
+import { setDeploymentStatus } from "./maintenance/setDeploymentStatus.js";
+import { getFunctionsData } from "./cloud-functions/getFunctionsData.js";
+import { retryOperation } from "@stoker-platform/utils";
+import { generateSchema } from "./schema/generateSchema.js";
+import isEqual from "lodash/isEqual.js";
+import cloneDeep from "lodash/cloneDeep.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const deployProject = async (options) => {
+    try {
+        await initializeFirebase();
+        if (options.retry) {
+            await runChildProcess("npx", ["stoker", "deployment", "--status", "idle"]);
+        }
+        if (!options.initial) {
+            const currentSchema = await generateSchema();
+            const lastSchema = await fetchCurrentSchema();
+            const currentScemaCopy = cloneDeep(currentSchema);
+            delete currentScemaCopy.published_time;
+            delete currentScemaCopy.version;
+            const lastSchemaCopy = cloneDeep(lastSchema);
+            delete lastSchemaCopy.published_time;
+            delete lastSchemaCopy.version;
+            if (!options.maintenanceOn && !isEqual(currentScemaCopy, lastSchemaCopy)) {
+                throw new Error("The schema for this project has changed. Maintenance mode cannot be disabled.");
+            }
+        }
+        await runChildProcess("npm", ["run", "format"]);
+        await runChildProcess("npm", ["run", "lint"]);
+        await runChildProcess("npm", ["run", "build"]);
+        await runChildProcess("npm", ["run", "test"]);
+        await runChildProcess("npx", ["stoker", "build-web-app"]);
+        await runChildProcess("npx", ["stoker", "lint-schema"]);
+        await runChildProcess("npx", ["stoker", "security-report"]);
+        await setDeploymentStatus("in_progress");
+        if (options.maintenanceOn && !options.initial)
+            await runChildProcess("npx", ["stoker", "maintenance", "--status", "on"]);
+        if (options.export) {
+            await runChildProcess("npx", ["stoker", "export"]);
+        }
+        if (!options.retry || options.initial) {
+            await runChildProcess("npx", ["stoker", "persist-schema"]);
+        }
+        await runChildProcess("npx", ["stoker", "deploy-ttls"]);
+        await runChildProcess("npx", ["stoker", "generate-firestore-indexes"]);
+        if (options.firestoreRules)
+            await runChildProcess("npx", ["stoker", "generate-firestore-rules"]);
+        if (options.storageRules)
+            await runChildProcess("npx", ["stoker", "generate-storage-rules"]);
+        await getFunctionsData();
+        if (options.migrate && !options.initial) {
+            await runChildProcess("npx", ["stoker", "migrate"]);
+        }
+        await initializeFirebase();
+        if (options.initial) {
+            await retryOperation(async () => {
+                await runChildProcess("npx", [
+                    "firebase",
+                    "deploy",
+                    "--only",
+                    "firestore,database,storage",
+                    "--project",
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    process.env.GCP_PROJECT,
+                    "--force",
+                ]);
+            }, [], undefined, 10000);
+            await retryOperation(async () => {
+                const output = await runChildProcess("npx", [
+                    "firebase",
+                    "deploy",
+                    "--only",
+                    "functions",
+                    "--project",
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    process.env.GCP_PROJECT,
+                    "--force",
+                ], undefined, { ...process.env, FUNCTIONS_DISCOVERY_TIMEOUT: "30" });
+                if (output.includes("HTTP Error: 400"))
+                    throw new Error("PERMISSION_DENIED");
+            }, [], undefined, 10000);
+            await retryOperation(async () => {
+                await runChildProcess("npx", [
+                    "firebase",
+                    "deploy",
+                    "--only",
+                    "extensions",
+                    "--project",
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    process.env.GCP_PROJECT,
+                    "--force",
+                ]);
+            }, [], undefined, 10000);
+        }
+        else {
+            await runChildProcess("npx", 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            ["firebase", "deploy", "--project", process.env.GCP_PROJECT, "--force"], undefined, { ...process.env, FUNCTIONS_DISCOVERY_TIMEOUT: "30" });
+        }
+        if (options.admin)
+            await runChildProcess("npm", ["exec", "--package=@stoker-platform/web-app", "--", "deploy-web-app"]);
+        const liveUpdateOptions = [];
+        if (options.secure && !options.initial)
+            liveUpdateOptions.push("--secure");
+        if (options.refresh && !options.initial)
+            liveUpdateOptions.push("--refresh");
+        await runChildProcess("npx", ["stoker", "live-update", ...liveUpdateOptions]);
+        if (options.maintenanceOff)
+            await runChildProcess("npx", ["stoker", "maintenance", "--status", "off"]);
+        await setDeploymentStatus("idle");
+        process.exit();
+    }
+    catch (error) {
+        throw new Error("Error deploying project.", { cause: error });
+    }
+};