@stoker-platform/cli 0.5.12

package/lib/src/project/addRecord.js

@@ -0,0 +1,9 @@
+import { addRecord as addStokerRecord, initializeStoker } from "@stoker-platform/node-client";
+import { join } from "path";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const addRecord = async (options) => {
+    await initializeStoker(options.mode || "production", options.tenant, join(process.cwd(), "lib", "main.js"), join(process.cwd(), "lib", "collections"));
+    const result = await addStokerRecord(options.path.split("/"), JSON.parse(options.data), options.userData ? JSON.parse(options.userData) : undefined, options.user);
+    console.log(JSON.stringify(result, null, 2));
+    process.exit();
+};

package/lib/src/project/addRecordPrompt.js

@@ -0,0 +1,205 @@
+import { input, password, select } from "@inquirer/prompts";
+import { addRecord, fetchCurrentSchema, getOne, initializeStoker } from "@stoker-platform/node-client";
+import { getField, getFieldCustomization, isRelationField, tryFunction } from "@stoker-platform/utils";
+import { Timestamp } from "firebase-admin/firestore";
+import { join } from "node:path";
+export const addRecordPrompt = async (tenantId, collectionName, fullAccess, mode, relationIds) => {
+    const { getCustomizationFile } = (await initializeStoker(mode || "production", tenantId, join(process.cwd(), "lib", "main.js"), join(process.cwd(), "lib", "collections")));
+    const schema = await fetchCurrentSchema();
+    // eslint-disable-next-line security/detect-object-injection
+    const collection = schema.collections[collectionName];
+    if (!collection)
+        throw new Error(`Collection ${collectionName} not found in schema`);
+    if (collection.parentCollection)
+        throw new Error("The CLI prompt does not support adding to subcollections");
+    const { labels, fields, softDelete } = collection;
+    const record = {};
+    const user = {};
+    const customization = getCustomizationFile(labels.collection, schema);
+    for (const field of fields) {
+        const fieldCustomization = getFieldCustomization(field, customization);
+        if (!("autoIncrement" in field && field.autoIncrement) &&
+            !fieldCustomization.custom?.initialValue &&
+            !(collection.auth && field.name === "User_ID") &&
+            !(softDelete && (field.name === softDelete.archivedField || field.name === softDelete.timestampField)) &&
+            !(isRelationField(field) && ["ManyToMany", "ManyToOne"].includes(field.type)) &&
+            field.type !== "Embedding" &&
+            field.type !== "Array" &&
+            field.type !== "Map" &&
+            !(field.type === "String" && tryFunction(fieldCustomization.admin?.image))) {
+            if (isRelationField(field)) {
+                let value;
+                if (relationIds?.[field.collection]) {
+                    value = relationIds[field.collection];
+                }
+                else {
+                    value = await input({
+                        message: `${labels.collection}- ${field.name}${field.required ? "*" : ""}`,
+                    });
+                }
+                if (value) {
+                    /* eslint-disable security/detect-object-injection */
+                    const relationRecord = await getOne([field.collection], value);
+                    record[field.name] ||= {};
+                    record[field.name][value] = {
+                        Collection_Path: relationRecord.Collection_Path,
+                    };
+                    if (field.includeFields) {
+                        for (const includeField of field.includeFields) {
+                            if (relationRecord[includeField]) {
+                                record[field.name][value][includeField] = relationRecord[includeField];
+                            }
+                        }
+                    }
+                    /* eslint-enable security/detect-object-injection */
+                }
+            }
+            else if (field.type === "Timestamp") {
+                const value = await input({
+                    message: `${labels.collection}- ${field.name}${field.required ? "*" : ""}`,
+                });
+                if (value) {
+                    record[field.name] = Timestamp.fromMillis(Number(value));
+                }
+            }
+            else if (field.type !== "Boolean") {
+                if ("values" in field && field.values) {
+                    record[field.name] = await select({
+                        message: `${labels.collection}- ${field.name}${field.required ? "*" : ""}`,
+                        choices: field.values.map((value) => {
+                            return { value: value };
+                        }),
+                    });
+                }
+                else {
+                    const value = await input({
+                        message: `${labels.collection}- ${field.name}${field.required ? "*" : ""}`,
+                    });
+                    if (field.type === "Number") {
+                        record[field.name] = Number(value);
+                    }
+                    else {
+                        record[field.name] = value;
+                    }
+                }
+            }
+            else {
+                record[field.name] = await select({
+                    message: `${labels.collection}- ${field.name}${field.required ? "*" : ""}`,
+                    choices: [
+                        { name: "TRUE", value: true },
+                        { name: "FALSE", value: false },
+                    ],
+                });
+            }
+        }
+    }
+    if (collection.auth) {
+        user.permissions = {};
+        user.permissions.Role = record.Role;
+        user.permissions.collections = {};
+        for (const [collectionName, collection] of Object.entries(schema.collections)) {
+            // eslint-disable-next-line security/detect-object-injection
+            user.permissions.collections[collectionName] = {
+                operations: [],
+            };
+            const assignable = collection.access.operations.assignable;
+            for (const operationType of ["read", "create", "update", "delete"]) {
+                const operationTypeUpper = (operationType.charAt(0).toUpperCase() + operationType.slice(1));
+                const operation = collection.access.operations[operationType];
+                if (typeof operation === "object" && operation.includes(record.Role)) {
+                    if (fullAccess) {
+                        // eslint-disable-next-line security/detect-object-injection
+                        user.permissions.collections[collectionName].operations.push(operationTypeUpper);
+                    }
+                    else {
+                        if (!(assignable === true ||
+                            (typeof assignable === "object" && assignable?.includes(record.Role)))) {
+                            // eslint-disable-next-line security/detect-object-injection
+                            user.permissions.collections[collectionName].operations.push(operationTypeUpper);
+                        }
+                    }
+                }
+            }
+            if (collection.auth && collection.access.auth?.includes(record.Role)) {
+                // eslint-disable-next-line security/detect-object-injection
+                user.permissions.collections[collectionName].auth = true;
+            }
+            if (collection.access.attributeRestrictions) {
+                for (const attributeRestriction of collection.access.attributeRestrictions) {
+                    if ("roles" in attributeRestriction) {
+                        const role = attributeRestriction.roles.find((role) => role.role === record.Role);
+                        if (!role)
+                            continue;
+                        if (role.assignable)
+                            continue;
+                        if (attributeRestriction.type === "Record_Owner") {
+                            // eslint-disable-next-line security/detect-object-injection
+                            user.permissions.collections[collectionName].recordOwner = { active: true };
+                        }
+                        if (attributeRestriction.type === "Record_User") {
+                            // eslint-disable-next-line security/detect-object-injection
+                            user.permissions.collections[collectionName].recordUser = { active: true };
+                        }
+                        if (attributeRestriction.type === "Record_Property") {
+                            // eslint-disable-next-line security/detect-object-injection
+                            user.permissions.collections[collectionName].recordProperty = { active: true };
+                        }
+                    }
+                }
+            }
+            if (collection.access.entityRestrictions?.restrictions) {
+                if (collection.access.entityRestrictions?.assignable?.includes(record.Role))
+                    continue;
+                let hasEntityRestrictions = false;
+                for (const entityRestriction of collection.access.entityRestrictions.restrictions) {
+                    if ("roles" in entityRestriction) {
+                        const role = entityRestriction.roles.find((role) => role.role === record.Role);
+                        if (!role)
+                            continue;
+                        if (entityRestriction.type === "Individual") {
+                            // eslint-disable-next-line security/detect-object-injection
+                            user.permissions.collections[collectionName].individualEntities = [];
+                            hasEntityRestrictions = true;
+                        }
+                        if (entityRestriction.type === "Parent") {
+                            // eslint-disable-next-line security/detect-object-injection
+                            const collectionField = getField(collection.fields, entityRestriction.collectionField);
+                            if (isRelationField(collectionField)) {
+                                // eslint-disable-next-line security/detect-object-injection
+                                user.permissions.collections[collectionName].parentEntities = [];
+                                hasEntityRestrictions = true;
+                            }
+                        }
+                        if (entityRestriction.type === "Parent_Property") {
+                            const collectionField = getField(collection.fields, entityRestriction.collectionField);
+                            if (isRelationField(collectionField)) {
+                                // eslint-disable-next-line security/detect-object-injection
+                                user.permissions.collections[collectionName].parentPropertyEntities = {};
+                                hasEntityRestrictions = true;
+                            }
+                        }
+                    }
+                }
+                if (hasEntityRestrictions) {
+                    // eslint-disable-next-line security/detect-object-injection
+                    user.permissions.collections[collectionName].restrictEntities = true;
+                }
+            }
+        }
+        user.password = await password({
+            message: `${labels.collection}- Password*`,
+            mask: true,
+        });
+    }
+    for (const field of Object.entries(record)) {
+        const [fieldName, fieldValue] = field;
+        if (fieldValue === "") {
+            // eslint-disable-next-line security/detect-object-injection
+            delete record[fieldName];
+        }
+    }
+    const result = await addRecord([labels.collection], record, user);
+    console.log(result);
+    return result;
+};

package/lib/src/project/addTenant.js

@@ -0,0 +1,59 @@
+import { input } from "@inquirer/prompts";
+import { fetchCurrentSchema, initializeFirebase, initializeStoker } from "@stoker-platform/node-client";
+import { getFirestore } from "firebase-admin/firestore";
+import { join } from "path";
+import { retryOperation, isRelationField } from "@stoker-platform/utils";
+import { addRecordPrompt } from "./addRecordPrompt.js";
+export const addTenant = async () => {
+    await initializeFirebase();
+    const db = getFirestore();
+    const doc = await db.collection("tenants").add({});
+    const tenantId = doc.id;
+    await initializeStoker("production", tenantId, join(process.cwd(), "lib", "main.js"), join(process.cwd(), "lib", "collections"));
+    const schema = await fetchCurrentSchema();
+    const collections = Object.entries(schema.collections);
+    for (const collectionSchema of collections) {
+        const [collectionName, collection] = collectionSchema;
+        const { fields } = collection;
+        for (const field of fields) {
+            if ("autoIncrement" in field && field.autoIncrement) {
+                const initialValue = await input({
+                    message: `Initial value for ${field.name} in collection ${collectionName}`,
+                });
+                await db
+                    .collection("tenants")
+                    .doc(tenantId)
+                    .collection("system_auto_increment")
+                    .doc(collectionName)
+                    .collection("fields")
+                    .doc(field.name)
+                    .set({ number: parseInt(initialValue) });
+            }
+        }
+    }
+    const collectionRecordCreated = [];
+    const relationIds = {};
+    for (const [collectionName, collection] of Object.entries(schema.collections)) {
+        if (collection.auth || collection.singleton) {
+            for (const field of collection.fields) {
+                if (isRelationField(field) && field.required) {
+                    if (!collectionRecordCreated.includes(field.collection)) {
+                        await retryOperation(async () => {
+                            const result = await addRecordPrompt(tenantId, field.collection, collection.auth);
+                            relationIds[field.collection] = result.id;
+                        }, [], (error) => console.log(error), 0, 100);
+                        collectionRecordCreated.push(field.collection);
+                    }
+                }
+            }
+            if (!collectionRecordCreated.includes(collectionName)) {
+                await retryOperation(async () => {
+                    await addRecordPrompt(tenantId, collectionName, collection.auth, undefined, relationIds);
+                }, [], (error) => console.log(error), 0, 100);
+                collectionRecordCreated.push(collectionName);
+            }
+        }
+    }
+    console.log(`Tenant ${tenantId} created successfully.`);
+    return;
+};

package/lib/src/project/buildWebApp.js

@@ -0,0 +1,10 @@
+import { runChildProcess } from "@stoker-platform/node-client";
+export const buildWebApp = async () => {
+    try {
+        await runChildProcess("npm", ["exec", "--package=@stoker-platform/web-app", "--", "build-web-app"]);
+        process.exit();
+    }
+    catch {
+        throw new Error("Error building the web app.");
+    }
+};

package/lib/src/project/customDomain.js

@@ -0,0 +1,157 @@
+import { runChildProcess } from "@stoker-platform/node-client";
+import { unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const customDomain = async (options) => {
+    if (!process.env.GCP_PROJECT) {
+        throw new Error("GCP_PROJECT environment variable is not set.");
+    }
+    const projectId = process.env.GCP_PROJECT;
+    const token = await runChildProcess("gcloud", ["auth", "print-access-token"]).catch(() => {
+        throw new Error("Error getting Google Cloud identity token.");
+    });
+    const hostingResponse = await fetch(`https://firebasehosting.googleapis.com/v1beta1/projects/${projectId}/sites/${projectId}/customDomains?parent=projects/${projectId}/sites/${projectId}&customDomainId=${options.domain}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": projectId,
+        },
+        body: "{}",
+    });
+    const hostingResponseJson = await hostingResponse.json();
+    console.log(hostingResponseJson);
+    if (!hostingResponse.ok) {
+        throw new Error("Error adding custom domain.");
+    }
+    const listKeysResponse = await fetch(`https://recaptchaenterprise.googleapis.com/v1/projects/${projectId}/keys`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": projectId,
+        },
+    });
+    const listKeysJson = await listKeysResponse.json();
+    const appCheckKey = listKeysJson.keys?.find((key) => key.displayName === "Firebase App Check");
+    if (!appCheckKey) {
+        throw new Error("Could not find existing App Check key");
+    }
+    const recaptchaResponse = await fetch(`https://recaptchaenterprise.googleapis.com/v1/projects/${projectId}/keys/${appCheckKey.name.split("/").pop()}?updateMask=webSettings.allowedDomains`, {
+        method: "PATCH",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": projectId,
+        },
+        body: JSON.stringify({
+            webSettings: {
+                ...appCheckKey.webSettings,
+                allowedDomains: [...(appCheckKey.webSettings.allowedDomains || []), options.domain],
+            },
+        }),
+    });
+    const recaptchaResponseJson = await recaptchaResponse.json();
+    console.log(recaptchaResponseJson);
+    if (!recaptchaResponse.ok) {
+        throw new Error("Failed to update Recaptcha key");
+    }
+    const authResponse = await fetch(`https://identitytoolkit.googleapis.com/admin/v2/projects/${projectId}/config`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": projectId,
+        },
+    });
+    const authResponseJson = await authResponse.json();
+    console.log(authResponseJson);
+    if (!authResponse.ok) {
+        throw new Error("Error getting Firebase Auth authorized domains.");
+    }
+    const auth = await fetch(`https://identitytoolkit.googleapis.com/admin/v2/projects/${projectId}/config`, {
+        method: "PATCH",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "X-Goog-User-Project": projectId,
+        },
+        body: JSON.stringify({
+            ...authResponseJson,
+            authorizedDomains: [...(authResponseJson.authorizedDomains || []), options.domain],
+        }),
+    });
+    const authUpdateResponse = await auth.json();
+    console.log(authUpdateResponse);
+    if (!auth.ok) {
+        throw new Error("Error updating Firebase Auth authorized domains.");
+    }
+    const apiKeys = await runChildProcess("gcloud", [
+        "services",
+        "api-keys",
+        "list",
+        `--project=${projectId}`,
+        "--quiet",
+        "--format=json",
+    ]);
+    const apiKeysJson = JSON.parse(apiKeys);
+    const apiKey = apiKeysJson[0];
+    if (!apiKey) {
+        throw new Error("Error getting Firebase API key.");
+    }
+    const allowedReferrers = `--allowed-referrers=${[...apiKey.restrictions.browserKeyRestrictions.allowedReferrers, `https://${options.domain}`].join(",")}`;
+    const apiKeyUpdateArgs = [
+        "services",
+        "api-keys",
+        "update",
+        apiKey.uid,
+        allowedReferrers,
+        `--project=${projectId}`,
+        "--quiet",
+    ];
+    await runChildProcess("gcloud", apiKeyUpdateArgs);
+    if (!process.env.FB_STORAGE_CORS) {
+        const corsConfigString = await runChildProcess("gcloud", [
+            "storage",
+            "buckets",
+            "describe",
+            `gs://${projectId}`,
+            `--project=${projectId}`,
+            "--format=json",
+        ]);
+        const corsConfigJson = JSON.parse(corsConfigString);
+        const existingCors = corsConfigJson.cors || [];
+        const allOrigins = new Set();
+        for (const corsEntry of existingCors) {
+            if (corsEntry.origin) {
+                for (const origin of corsEntry.origin) {
+                    allOrigins.add(origin);
+                }
+            }
+        }
+        allOrigins.add(`https://${options.domain}`);
+        const corsToWrite = [
+            {
+                origin: Array.from(allOrigins),
+                method: ["GET"],
+                maxAgeSeconds: 3600,
+            },
+        ];
+        await writeFile("cors.json", JSON.stringify(corsToWrite));
+        await runChildProcess("gcloud", [
+            "storage",
+            "buckets",
+            "update",
+            `gs://${projectId}`,
+            "--cors-file",
+            "cors.json",
+            `--project=${projectId}`,
+            "--quiet",
+        ]).catch(() => {
+            throw new Error("Error updating Cloud Storage CORS.");
+        });
+        await unlink(join(process.cwd(), "cors.json"));
+    }
+};

package/lib/src/project/deleteProject.js

@@ -0,0 +1,51 @@
+import { runChildProcess } from "@stoker-platform/node-client";
+import { readFile, rm, unlink, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+export const deleteProject = async (options) => {
+    if (!process.env.GCP_PROJECT) {
+        throw new Error("GCP_PROJECT is not set.");
+    }
+    await runChildProcess("gcloud", ["projects", "delete", process.env.GCP_PROJECT, "--quiet"]).catch(() => {
+        throw new Error("Error deleting project.");
+    });
+    console.log("Project deleted.");
+    if (!options.testMode) {
+        const projectData = JSON.parse(await readFile(join(process.cwd(), "project-data.json"), "utf8"));
+        delete projectData.projects[process.env.GCP_PROJECT];
+        projectData.deleted_projects.push(process.env.GCP_PROJECT);
+        await writeFile(join(process.cwd(), "project-data.json"), JSON.stringify(projectData, null, 4));
+        console.log("Project deleted from project data.");
+    }
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    if (existsSync(join(process.cwd(), ".env", `.env.${process.env.GCP_PROJECT}`))) {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        await unlink(join(process.cwd(), ".env", `.env.${process.env.GCP_PROJECT}`));
+        console.log("System environment file deleted.");
+    }
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    if (existsSync(join(process.cwd(), ".env", `.env.project.${process.env.GCP_PROJECT}`))) {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        await unlink(join(process.cwd(), ".env", `.env.project.${process.env.GCP_PROJECT}`));
+        console.log("Project environment file deleted.");
+    }
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    if (existsSync(join(process.cwd(), ".migration", process.env.GCP_PROJECT))) {
+        await rm(join(process.cwd(), ".migration", process.env.GCP_PROJECT), { recursive: true, force: true });
+        console.log("Project migration folder deleted.");
+    }
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    const firebaserc = JSON.parse(await readFile(join(process.cwd(), ".firebaserc"), "utf8"));
+    if (firebaserc.targets) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        delete firebaserc.targets[process.env.GCP_PROJECT];
+        console.log("Project removed from .firebaserc targets.");
+    }
+    if (firebaserc.etags) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        delete firebaserc.etags[process.env.GCP_PROJECT];
+        console.log("Project removed from .firebaserc etags.");
+    }
+    await writeFile(join(process.cwd(), ".firebaserc"), JSON.stringify(firebaserc, null, 2));
+    process.exit();
+};

package/lib/src/project/deleteRecord.js

@@ -0,0 +1,11 @@
+import { deleteRecord as deleteStokerRecord, initializeStoker } from "@stoker-platform/node-client";
+import { join } from "path";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const deleteRecord = async (options) => {
+    await initializeStoker(options.mode || "production", options.tenant, join(process.cwd(), "lib", "main.js"), join(process.cwd(), "lib", "collections"));
+    const deletedRecord = await deleteStokerRecord(options.path.split("/"), options.id, options.user, {
+        force: options.force,
+    });
+    console.log(JSON.stringify(deletedRecord, null, 2));
+    process.exit();
+};

package/lib/src/project/deleteTenant.js

@@ -0,0 +1,49 @@
+import { fetchCurrentSchema, initializeFirebase } from "@stoker-platform/node-client";
+import { getAuth } from "firebase-admin/auth";
+import { getFirestore } from "firebase-admin/firestore";
+import { getStorage } from "firebase-admin/storage";
+import { getApp } from "firebase-admin/app";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const deleteTenant = async (options) => {
+    await initializeFirebase();
+    const app = getApp();
+    const auth = getAuth();
+    const db = getFirestore();
+    const storage = getStorage();
+    const schema = await fetchCurrentSchema();
+    const users = await db.collection("tenants").doc(options.tenant).collection("system_user_permissions").get();
+    for (const snapshot of users.docs) {
+        await auth.deleteUser(snapshot.id);
+    }
+    const deleteCollectionRecursively = async (collectionRef) => {
+        const snapshots = await collectionRef.get();
+        for (const doc of snapshots.docs) {
+            const subcollections = await doc.ref.listCollections();
+            for (const subcollection of subcollections) {
+                await deleteCollectionRecursively(subcollection);
+            }
+            await doc.ref.delete();
+        }
+    };
+    const tenantRef = db.collection("tenants").doc(options.tenant);
+    const subcollections = await tenantRef.listCollections();
+    for (const subcollection of subcollections) {
+        if (subcollection.id === "system_auto_increment" || subcollection.id === "system_fields") {
+            for (const collection of Object.values(schema.collections)) {
+                const subcollections = await subcollection.doc(collection.labels.collection).listCollections();
+                for (const subcollection of subcollections) {
+                    await deleteCollectionRecursively(subcollection);
+                }
+            }
+        }
+        await deleteCollectionRecursively(subcollection);
+    }
+    await tenantRef.delete();
+    const bucket = storage.bucket(app.options.projectId);
+    const [files] = await bucket.getFiles({
+        prefix: `${options.tenant}/`,
+    });
+    await Promise.all(files.map((file) => file.delete()));
+    console.log("Tenant deleted.");
+    process.exit();
+};

package/lib/src/project/getOne.js

@@ -0,0 +1,25 @@
+import { initializeStoker, getOne as getOneStoker } from "@stoker-platform/node-client";
+import { join } from "path";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const getOne = async (options) => {
+    await initializeStoker(options.mode || "production", options.tenant, join(process.cwd(), "lib", "main.js"), join(process.cwd(), "lib", "collections"));
+    const path = options.path.split("/");
+    const id = path.pop();
+    const getOneOptions = {};
+    if (options.subcollections) {
+        getOneOptions.subcollections = {
+            depth: options.subcollections,
+        };
+    }
+    if (options.relations) {
+        getOneOptions.relations = {
+            depth: options.relations,
+        };
+    }
+    if (options.user) {
+        getOneOptions.user = options.user;
+    }
+    const result = await getOneStoker(path, id, getOneOptions);
+    console.log(JSON.stringify(result, null, 2));
+    process.exit();
+};

package/lib/src/project/getSome.js

@@ -0,0 +1,28 @@
+import { initializeStoker, getSome as getSomeStoker } from "@stoker-platform/node-client";
+import { join } from "path";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const getSome = async (options) => {
+    await initializeStoker(options.mode || "production", options.tenant, join(process.cwd(), "lib", "main.js"), join(process.cwd(), "lib", "collections"));
+    const path = options.path.split("/");
+    let constraints = [];
+    if (options.constraints) {
+        constraints = JSON.parse(options.constraints);
+    }
+    const getSomeOptions = {};
+    if (options.subcollections) {
+        getSomeOptions.subcollections = {
+            depth: options.subcollections,
+        };
+    }
+    if (options.relations) {
+        getSomeOptions.relations = {
+            depth: options.relations,
+        };
+    }
+    if (options.user) {
+        getSomeOptions.user = options.user;
+    }
+    const result = await getSomeStoker(path, constraints, getSomeOptions);
+    console.log(JSON.stringify(result.docs, null, 2));
+    process.exit();
+};

package/lib/src/project/initProject.js

@@ -0,0 +1,16 @@
+import { fileURLToPath } from "url";
+import { resolve, dirname, join } from "path";
+import { existsSync, cpSync, renameSync } from "fs";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const initProject = async (options) => {
+    if (existsSync("firebase.json") && !options.force) {
+        console.log("Please run this command from an empty directory");
+        process.exit();
+    }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    cpSync(resolve(__dirname, "..", "..", "..", "init-files"), process.cwd(), { recursive: true });
+    renameSync(join(process.cwd(), ".##gitignore##"), join(process.cwd(), ".gitignore"));
+    renameSync(join(process.cwd(), "functions", ".##gitignore##"), join(process.cwd(), "functions", ".gitignore"));
+    process.exit();
+};