@stoker-platform/cli 0.5.82 → 0.5.86

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stoker-platform/cli",
-    "version": "0.5.81",
+    "version": "0.5.85",
     "type": "module",
     "license": "SEE LICENSE IN LICENSE.md",
     "main": "./lib/src/main.js",
@@ -24,9 +24,9 @@
         "@google-cloud/secret-manager": "^6.1.1",
         "@google-cloud/storage": "^7.19.0",
         "@inquirer/prompts": "^8.4.2",
-        "@stoker-platform/node-client": "0.5.58",
-        "@stoker-platform/types": "0.5.37",
-        "@stoker-platform/utils": "0.5.49",
+        "@stoker-platform/node-client": "0.5.59",
+        "@stoker-platform/types": "0.5.38",
+        "@stoker-platform/utils": "0.5.50",
         "algoliasearch": "^5.51.0",
         "commander": "^14.0.0",
         "cross-spawn": "^7.0.6",

package/lib/src/deploy/deployProject.js

@@ -25,6 +25,7 @@ export const deployProject = async (options) => {
                 throw new Error("The schema for this project has changed. Maintenance mode cannot be disabled.");
             }
         }
+        await runChildProcess("npx", ["stoker", "generate-types"]);
         await runChildProcess("npm", ["run", "format"]);
         await runChildProcess("npm", ["run", "lint"]);
         await runChildProcess("npm", ["run", "build"]);

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

@@ -1,184 +1,216 @@
 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 { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { readdir, readFile, rm } from "fs/promises";
 import { join } from "path";
 import { pathToFileURL } from "url";
-export const generateSchema = async (includeComputedFields = false) => {
+const ensureSchemaBuildOutput = (isTypeGen) => {
+    if (!isTypeGen)
+        return;
+    const mainPath = join(process.cwd(), "lib", "main.js");
+    const collectionsPath = join(process.cwd(), "lib", "collections");
+    if (existsSync(mainPath) && existsSync(collectionsPath))
+        return;
+    const buildResult = spawnSync("npx", ["tsc", "--pretty", "false", "--noEmitOnError", "false"], {
+        cwd: process.cwd(),
+        stdio: "ignore",
+    });
+    if (buildResult.error) {
+        throw new Error("Failed to run TypeScript compile step for schema generation", { cause: buildResult.error });
+    }
+    if (!existsSync(mainPath) || !existsSync(collectionsPath)) {
+        throw new Error("No lib output found. Run 'npm run build' to generate lib artifacts.");
+    }
+    return true;
+};
+export const generateSchema = async (includeComputedFields = false, isTypeGen = 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({ sdk: "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 tempSchemaGenerated = ensureSchemaBuildOutput(isTypeGen);
+    try {
+        const path = join(process.cwd(), "lib", "main.js");
         const url = pathToFileURL(path).href;
-        const schema = await import(url);
-        fullSchema.push(schema.default({ sdk: "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({ sdk: "node" });
-        const { labels, access, preloadCache, admin } = persistSchema;
-        const { serverReadOnly } = access;
-        if (!includeComputedFields) {
-            persistSchema.fields = persistSchema.fields.filter((field) => field.type !== "Computed");
+        const globalConfigFile = await import(url);
+        const globalConfig = globalConfigFile.default({ sdk: "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({ sdk: "node" }));
         }
-        else {
-            for (const field of persistSchema.fields) {
-                if (field.type === "Computed") {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    delete field.formula;
-                }
+        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({ sdk: "node" });
+            const { labels, access, preloadCache, admin } = persistSchema;
+            const { serverReadOnly } = access;
+            if (!includeComputedFields) {
+                persistSchema.fields = persistSchema.fields.filter((field) => field.type !== "Computed");
             }
-        }
-        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,
-                });
+            else {
+                for (const field of persistSchema.fields) {
+                    if (field.type === "Computed") {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        delete field.formula;
+                    }
+                }
             }
-            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);
+            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);
                             }
-                            existingRelationFilter.roles = Array.from(newRoles);
+                        }
+                        else {
+                            filters.push({
+                                type: "relation",
+                                field: relationListField.field,
+                                roles: relationListField.roles?.filter((role) => noPreloadCacheRoles.includes(role)) ||
+                                    noPreloadCacheRoles,
+                            });
                         }
                     }
-                    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,
-                        });
+                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;
                     }
-                }
-                else {
-                    if (noPreloadCacheRoles.length === 0) {
-                        filters.splice(existingRangeIndex, 1);
+                    filters.push(newFilter);
+                    if (existingStatusFieldIndex !== -1) {
+                        filters.splice(existingStatusFieldIndex, 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;
+                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);
                         }
                     }
                 }
-                else {
-                    persistFilter.field = filter.field;
-                }
-                if ("roles" in filter && filter.roles?.length) {
-                    persistFilter.roles = filter.roles;
+                if ((cards || admin.images) && standardRoles.length) {
+                    filters.push({
+                        type: "select",
+                        field: "Last_Save_At",
+                        roles: standardRoles,
+                    });
                 }
-                if (addUnscheduledRoles) {
-                    if (persistFilter.roles?.length) {
-                        persistFilter.roles = persistFilter.roles?.filter((role) => calendar.unscheduled?.roles?.includes(role));
+                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.roles = calendar.unscheduled?.roles;
+                        persistFilter.field = filter.field;
                     }
-                }
-                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;
+                    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;
         }
-        delete persistSchema.custom;
-        delete persistSchema.admin;
-        for (const field of persistSchema.fields) {
-            delete field.custom;
-            delete field.admin;
+        return newSchema;
+    }
+    finally {
+        if (tempSchemaGenerated) {
+            const libPath = join(process.cwd(), "lib");
+            if (existsSync(libPath)) {
+                await rm(libPath, { recursive: true, force: true });
+            }
         }
-        newSchema.collections[collection.split(".")[0]] = persistSchema;
     }
-    return newSchema;
 };

package/lib/src/lint/lintSchema.js

@@ -126,25 +126,22 @@ export const lintSchema = async (noLog = false) => {
         }
     }
     for (const [collectionName, collectionSchema] of collectionSchemas) {
-        const { auth, fields, access, ttl, parentCollection, recordTitleField, softDelete, roleSystemFields, preloadCache, relationLists, fullTextSearch, ai, } = collectionSchema;
+        const { labels, auth, fields, access, ttl, parentCollection, recordTitleField, softDelete, roleSystemFields, preloadCache, relationLists, fullTextSearch, ai, } = collectionSchema;
         const { auth: authAccess, operations, attributeRestrictions, entityRestrictions, permissionWriteRestrictions, serverReadOnly, serverWriteOnly, files, } = access;
         // eslint-disable-next-line security/detect-object-injection
         const customization = customizationModules[collectionName];
         const readRoles = roles.filter((role) => roleHasOperationAccess(collectionSchema, role, "read"));
         const fieldNames = fields.map((field) => field.name);
-        const regex = /^(?!\/)(?!.*\/)(?!\.$)(?!\.\.$)(?!__.*__)[^/\s]{1,1500}$/;
-        if (!regex.test(collectionName)) {
+        const firestoreRegex = /^(?!\/)(?!.*\/)(?!\.$)(?!\.\.$)(?!__.*__)[^/\s]{1,1500}$/;
+        if (!firestoreRegex.test(collectionName)) {
             errors.push(`Invalid collection name: ${collectionName}. Must be a valid Firestore collection ID.`);
         }
-        if (collectionName.includes("?")) {
-            errors.push(`Invalid collection name: ${collectionName}. Collection names cannot contain question marks.`);
+        const tsIdentifierRegex = /^[A-Z][A-Za-z0-9_]*$/;
+        if (!tsIdentifierRegex.test(collectionName)) {
+            errors.push(`Invalid collection name: ${collectionName}. Must start with a capital letter and contain only letters, digits, and underscores.`);
         }
-        const formattedCollectionName = collectionName.replace(/\s+/g, "").replace(/^\w/, (c) => c.toUpperCase());
-        if (formattedCollectionName !== collectionName) {
-            errors.push(`Invalid collection name: ${collectionName}. Collection names should not have spaces and should start with a capital letter.`);
-        }
-        if (collectionName.includes("-")) {
-            errors.push(`Invalid collection name: ${collectionName}. Collection names cannot have dashes. Use underscores instead.`);
+        if (labels.collection !== collectionName) {
+            errors.push(`Invalid collection label: collection label "${labels.collection}" must match collection file name "${collectionName}".`);
         }
         fieldNames.forEach((fieldName) => {
             const formattedFieldName = fieldName.replace(/\s+/g, "").replace(/^\w/, (c) => c.toUpperCase());

package/lib/src/main.js

@@ -18,6 +18,7 @@ if (!process.env.GCP_PROJECT &&
         "generate-firestore-indexes",
         "generate-firestore-rules",
         "generate-storage-rules",
+        "generate-types",
         "add-project",
         "list-projects",
     ].includes(process.argv[2])) {
@@ -84,6 +85,7 @@ import { applySchema } from "./deploy/schema/applySchema.js";
 import { addTenant } from "./project/addTenant.js";
 import { deleteTenant } from "./project/deleteTenant.js";
 import { updateLiveSchema } from "./deploy/schema/updateLiveSchema.js";
+import { generateTypes } from "./types/generateTypes.js";
 const program = new Command();
 program.name("stoker").description("Stoker Platform CLI").version(pkg.version);
 program
@@ -196,6 +198,12 @@ program
     .action(() => {
     generateStorageRules();
 });
+program
+    .command("generate-types")
+    .description("generate TypeScript collection types")
+    .action(() => {
+    generateTypes();
+});
 program
     .command("deploy")
     .description("deploy project")

package/lib/src/types/generateTypes.js

@@ -0,0 +1,107 @@
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import { isRelationField } from "@stoker-platform/utils";
+import { generateSchema } from "../deploy/schema/generateSchema.js";
+const INDENT = "    ";
+const tsLiteral = (value) => JSON.stringify(value);
+const literalUnion = (values) => values.map(tsLiteral).join(" | ");
+const fieldType = (field, mode) => {
+    switch (field.type) {
+        case "String":
+            return field.values?.length ? literalUnion(field.values) : "string";
+        case "Boolean":
+            return "boolean";
+        case "Number":
+            if (field.values?.length)
+                return literalUnion(field.values);
+            if (field.autoIncrement) {
+                return mode === "record" ? `number | ${tsLiteral("Pending")}` : "number";
+            }
+            return "number";
+        case "Timestamp":
+            return "FirestoreTimestamp";
+        case "Array":
+            return field.values?.length ? `(${literalUnion(field.values)})[]` : "unknown[]";
+        case "Map":
+            return "Record<string, unknown>";
+        case "Embedding":
+            return "unknown";
+        case "Computed":
+            return mode === "record" ? "string | number" : "never";
+        default:
+            return "unknown";
+    }
+};
+const buildField = (field, mode) => {
+    if (field.type === "Embedding")
+        return [];
+    if (field.type === "Computed" && mode === "input")
+        return [];
+    if (isRelationField(field)) {
+        const required = Boolean(field.required);
+        const optional = required ? "" : "?";
+        if (mode === "input") {
+            return [`${INDENT}${tsLiteral(field.name)}${optional}: StokerRelationObject`];
+        }
+        return [
+            `${INDENT}${tsLiteral(field.name)}${optional}: StokerRelationObject`,
+            `${INDENT}${tsLiteral(`${field.name}_Array`)}${optional}: StokerRelationArray`,
+        ];
+    }
+    const isAutoIncrement = field.type === "Number" && field.autoIncrement;
+    const required = Boolean(field.required) && !(mode === "input" && isAutoIncrement);
+    const optional = required ? "" : "?";
+    const nullable = "nullable" in field && field.nullable ? " | null" : "";
+    return [`${INDENT}${tsLiteral(field.name)}${optional}: ${fieldType(field, mode)}${nullable}`];
+};
+const buildRecordType = (collection) => {
+    const typeName = `${collection.labels.collection}Record`;
+    const lines = collection.fields.flatMap((field) => buildField(field, "record"));
+    return [`export type ${typeName} = SystemFields & {`, ...lines, "}"].join("\n");
+};
+const buildCreateInputType = (collection) => {
+    const typeName = `${collection.labels.collection}CreateInput`;
+    const lines = collection.fields.flatMap((field) => buildField(field, "input"));
+    return [`export type ${typeName} = {`, ...lines, "}"].join("\n");
+};
+const buildUpdateInputType = (collection) => {
+    const typeName = collection.labels.collection;
+    return `export type ${typeName}UpdateInput = Partial<${typeName}CreateInput>`;
+};
+const buildMap = (mapName, collections, suffix) => {
+    const entries = collections.map((collection) => `${INDENT}${tsLiteral(collection.labels.collection)}: ${collection.labels.collection}${suffix}`);
+    return [`export type ${mapName} = {`, ...entries, "}"].join("\n");
+};
+const buildOutput = (collections) => {
+    const sections = [
+        "import type {",
+        `${INDENT}FirestoreTimestamp,`,
+        `${INDENT}SystemFields,`,
+        `${INDENT}StokerRelationArray,`,
+        `${INDENT}StokerRelationObject,`,
+        '} from "@stoker-platform/types"',
+        "",
+        [
+            "export type CollectionName =",
+            ...collections.map((collection) => `${INDENT}| ${tsLiteral(collection.labels.collection)}`),
+        ].join("\n"),
+        "",
+    ];
+    for (const collection of collections) {
+        sections.push(buildRecordType(collection), "", buildCreateInputType(collection), "", buildUpdateInputType(collection), "");
+    }
+    sections.push(buildMap("CollectionRecordMap", collections, "Record"), "", buildMap("CollectionCreateInputMap", collections, "CreateInput"), "", buildMap("CollectionUpdateInputMap", collections, "UpdateInput"), "", "export type CollectionRecord<C extends CollectionName> = CollectionRecordMap[C]", "export type CollectionCreateInput<C extends CollectionName> = CollectionCreateInputMap[C]", "export type CollectionUpdateInput<C extends CollectionName> = CollectionUpdateInputMap[C]", "");
+    return sections.join("\n");
+};
+export const generateTypes = async () => {
+    const schema = await generateSchema(true, true);
+    const collections = Object.values(schema.collections).sort((a, b) => a.labels.collection.localeCompare(b.labels.collection));
+    const outPath = join(process.cwd(), "src", "types.ts");
+    await writeFile(outPath, buildOutput(collections), "utf8");
+    if (collections.length === 1) {
+        console.log("Generated types for 1 collection");
+    }
+    else {
+        console.log(`Generated types for ${collections.length} collections`);
+    }
+};

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/main.ts","../src/data/exporttobigquery.ts","../src/data/seeddata.ts","../src/deploy/deployproject.ts","../src/deploy/cloud-functions/getfunctionsdata.ts","../src/deploy/firestore-export/exportfirestoredata.ts","../src/deploy/firestore-ttl/deployttls.ts","../src/deploy/live-update/liveupdate.ts","../src/deploy/maintenance/activatemaintenancemode.ts","../src/deploy/maintenance/disablemaintenancemode.ts","../src/deploy/maintenance/setdeploymentstatus.ts","../src/deploy/rules-indexes/generatefirestoreindexes.ts","../src/deploy/rules-indexes/generatefirestorerules.ts","../src/deploy/rules-indexes/generatestoragerules.ts","../src/deploy/schema/applyschema.ts","../src/deploy/schema/generateschema.ts","../src/deploy/schema/persistschema.ts","../src/deploy/schema/updateliveschema.ts","../src/lint/lintschema.ts","../src/lint/securityreport.ts","../src/migration/migrateall.ts","../src/migration/firestore/migratefirestore.ts","../src/migration/firestore/operations/deletefield.ts","../src/ops/auditdenormalized.ts","../src/ops/auditpermissions.ts","../src/ops/auditrelations.ts","../src/ops/explainpreloadqueries.ts","../src/ops/getuser.ts","../src/ops/getuserpermissions.ts","../src/ops/getuserrecord.ts","../src/ops/listprojects.ts","../src/ops/setusercollection.ts","../src/ops/setuserdocument.ts","../src/ops/setuserrole.ts","../src/project/addproject.ts","../src/project/addrecord.ts","../src/project/addrecordprompt.ts","../src/project/addtenant.ts","../src/project/buildwebapp.ts","../src/project/customdomain.ts","../src/project/deleteproject.ts","../src/project/deleterecord.ts","../src/project/deletetenant.ts","../src/project/getone.ts","../src/project/getsome.ts","../src/project/initproject.ts","../src/project/prepareemulatordata.ts","../src/project/setproject.ts","../src/project/startemulators.ts","../src/project/updaterecord.ts"],"version":"6.0.3"}
+{"root":["../src/main.ts","../src/data/exporttobigquery.ts","../src/data/seeddata.ts","../src/deploy/deployproject.ts","../src/deploy/cloud-functions/getfunctionsdata.ts","../src/deploy/firestore-export/exportfirestoredata.ts","../src/deploy/firestore-ttl/deployttls.ts","../src/deploy/live-update/liveupdate.ts","../src/deploy/maintenance/activatemaintenancemode.ts","../src/deploy/maintenance/disablemaintenancemode.ts","../src/deploy/maintenance/setdeploymentstatus.ts","../src/deploy/rules-indexes/generatefirestoreindexes.ts","../src/deploy/rules-indexes/generatefirestorerules.ts","../src/deploy/rules-indexes/generatestoragerules.ts","../src/deploy/schema/applyschema.ts","../src/deploy/schema/generateschema.ts","../src/deploy/schema/persistschema.ts","../src/deploy/schema/updateliveschema.ts","../src/lint/lintschema.ts","../src/lint/securityreport.ts","../src/migration/migrateall.ts","../src/migration/firestore/migratefirestore.ts","../src/migration/firestore/operations/deletefield.ts","../src/ops/auditdenormalized.ts","../src/ops/auditpermissions.ts","../src/ops/auditrelations.ts","../src/ops/explainpreloadqueries.ts","../src/ops/getuser.ts","../src/ops/getuserpermissions.ts","../src/ops/getuserrecord.ts","../src/ops/listprojects.ts","../src/ops/setusercollection.ts","../src/ops/setuserdocument.ts","../src/ops/setuserrole.ts","../src/project/addproject.ts","../src/project/addrecord.ts","../src/project/addrecordprompt.ts","../src/project/addtenant.ts","../src/project/buildwebapp.ts","../src/project/customdomain.ts","../src/project/deleteproject.ts","../src/project/deleterecord.ts","../src/project/deletetenant.ts","../src/project/getone.ts","../src/project/getsome.ts","../src/project/initproject.ts","../src/project/prepareemulatordata.ts","../src/project/setproject.ts","../src/project/startemulators.ts","../src/project/updaterecord.ts","../src/types/generatetypes.ts"],"version":"6.0.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stoker-platform/cli",
-    "version": "0.5.82",
+    "version": "0.5.86",
     "type": "module",
     "license": "SEE LICENSE IN LICENSE.md",
     "main": "./lib/src/main.js",
@@ -24,9 +24,9 @@
         "@google-cloud/secret-manager": "^6.1.1",
         "@google-cloud/storage": "^7.19.0",
         "@inquirer/prompts": "^8.4.2",
-        "@stoker-platform/node-client": "0.5.58",
-        "@stoker-platform/types": "0.5.37",
-        "@stoker-platform/utils": "0.5.49",
+        "@stoker-platform/node-client": "0.5.60",
+        "@stoker-platform/types": "0.5.39",
+        "@stoker-platform/utils": "0.5.51",
         "algoliasearch": "^5.51.0",
         "commander": "^14.0.0",
         "cross-spawn": "^7.0.6",