@mxpicture/gcp-functions-generator 0.2.0

package/dist/generator/Generator.js

@@ -0,0 +1,132 @@
+import { basename, dirname } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { MetaFileExtension, MetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+import { directories } from "../common/Directories.js";
+import { toFilename, formatCode, formatJson, } from "@mxpicture/gcp-functions-code/common";
+import { metaBasenameAsync, metaBackendNamesAsync, metaFrontendNamesAsync, metaNamesAsync, } from "../meta/meta.names.js";
+const importToCode = (imp) => imp.props.length > 0
+    ? `import ${imp.isType ? "type " : ""}{ ${[...imp.props].join(", ")} } from "${imp.path}"`
+    : null;
+const importToCodeAsync = async (imp) => Promise.resolve().then(() => importToCode(imp));
+export const importsToCode = (imports) => imports.map(importToCode).filter((imp) => imp !== null);
+export const importsToCodeAsync = async (imports) => (await Promise.all(imports.map(importToCodeAsync))).filter((imp) => imp !== null);
+export class Generator {
+    type;
+    ext;
+    targetType;
+    collector;
+    useAdditionalImports;
+    constructor(type, ext, targetType, collector, useAdditionalImports = false) {
+        this.type = type;
+        this.ext = ext;
+        this.targetType = targetType;
+        this.collector = collector;
+        this.useAdditionalImports = useAdditionalImports;
+    }
+    async run(file) {
+        let result = null;
+        const interfaceResults = await Promise.all(file.headers.map((header) => this.processHeader(header)));
+        for (const interfaceResult of interfaceResults) {
+            if (!interfaceResult)
+                continue;
+            if (!result) {
+                const targetFilename = toFilename({
+                    filename: basename(interfaceResult.inputFilePath),
+                    type: this.type,
+                    ext: this.ext,
+                    generated: true,
+                });
+                result = {
+                    inputFilePath: interfaceResult.inputFilePath,
+                    targetFilePath: directories.toTargetPath(this.type, targetFilename, this.targetType),
+                    targetType: this.targetType,
+                    imports: [],
+                    importsCode: [],
+                    code: [],
+                    ext: this.ext,
+                    type: this.type,
+                };
+            }
+            this.addCode(result, interfaceResult.code);
+            this.addImports(result, interfaceResult.imports);
+        }
+        if (!result)
+            throw new Error(`Generator ${this.type}, file ${file.templateRepoFilePath}: no headers provided`);
+        result.importsCode = await importsToCodeAsync(result.imports);
+        return result;
+    }
+    static async write(...files) {
+        const promises = [];
+        for (const file of files) {
+            const preCode = [...file.importsCode, "", ...file.code].join("\n");
+            promises.push((async () => {
+                let code;
+                if (file.ext === MetaFileExtension.ts)
+                    code = await formatCode(preCode);
+                else if (file.ext === MetaFileExtension.json)
+                    code = await formatJson(preCode);
+                else
+                    code = preCode;
+                await mkdir(dirname(file.targetFilePath), { recursive: true });
+                return writeFile(file.targetFilePath, code);
+            })());
+        }
+        await Promise.all(promises);
+    }
+    resolveImport(targetType, fileType) {
+        return directories.resolveImport({ targetType, fileType }, { targetType: this.targetType, fileType: this.type });
+    }
+    importCommon(fileType) {
+        return this.resolveImport(MetaTargetType.common, fileType);
+    }
+    importFrontend(fileType) {
+        return this.resolveImport(MetaTargetType.frontend, fileType);
+    }
+    importBackend(fileType) {
+        return this.resolveImport(MetaTargetType.backend, fileType);
+    }
+    addCode(res, code) {
+        if (res.code.length > 0)
+            res.code.push("");
+        res.code.push(...code);
+    }
+    addImport(res, imp) {
+        let foundImp = res.imports.find((i) => i.path === imp.path && i.isType === imp.isType);
+        if (!foundImp) {
+            foundImp = {
+                ...imp,
+                props: [],
+            };
+            res.imports.push(foundImp);
+        }
+        for (const prop of imp.props)
+            if (!foundImp.props.find((p) => p === prop))
+                foundImp.props.push(prop);
+    }
+    addImports(res, imports) {
+        for (const imp of imports)
+            this.addImport(res, imp);
+    }
+    async processHeader(header) {
+        const extrName = await metaBasenameAsync(header.templateName);
+        const names = this.targetType === MetaTargetType.backend
+            ? await metaBackendNamesAsync(extrName, header.prefix)
+            : this.targetType === MetaTargetType.frontend
+                ? await metaFrontendNamesAsync(extrName, header.prefix)
+                : await metaNamesAsync(extrName, header.prefix);
+        this.collector.add(names.basename, this.targetType, { names });
+        const result = await this.runHeader(header, names);
+        if (!result)
+            return result;
+        return {
+            name: result.name,
+            inputFilePath: header.inputFilePath,
+            code: [...result.code],
+            imports: this.useAdditionalImports &&
+                header.additionalImports &&
+                header.additionalImports.length > 0
+                ? [...result.imports, ...header.additionalImports]
+                : [...result.imports],
+        };
+    }
+}

package/dist/generator/GeneratorAnnotations.d.ts

@@ -0,0 +1,9 @@
+import { MetaHeadData } from "@mxpicture/gcp-functions-common/meta";
+import { MetaNames } from "@mxpicture/gcp-functions-common/types";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorAnnotations extends Generator {
+    constructor();
+    protected runHeader(mainData: MetaHeadData, names: MetaNames): Promise<GeneratorCode | null>;
+}
+declare const _default: GeneratorAnnotations;
+export default _default;

package/dist/generator/GeneratorAnnotations.js

@@ -0,0 +1,65 @@
+import { MetaFileType, MetaFileExtension, MetaTargetType, mapAnnotationsHeader, } from "@mxpicture/gcp-functions-common/meta";
+import { Generator } from "./Generator.js";
+import { Collector } from "../common/Collector.js";
+import { formatJson2Spaces } from "@mxpicture/gcp-functions-code/common";
+const typeRegex = /\"type\": \"([a-zA-Z][a-zA-Z0-9]*)\"/;
+const itemTypeRegex = /\"itemType\": \"(MetaPropertyType\.|)([a-zA-Z][a-zA-Z0-9]*)\"/;
+const propertyRefRegex = /\"propertyRef\": \"([a-zA-Z][a-zA-Z0-9]*)\"/;
+export class GeneratorAnnotations extends Generator {
+    constructor() {
+        super(MetaFileType.annotations, MetaFileExtension.ts, MetaTargetType.common, Collector.instance());
+    }
+    async runHeader(mainData, names) {
+        const res = {
+            code: [],
+            imports: [
+                {
+                    path: "@mxpicture/gcp-functions-common/types",
+                    props: ["AnnotationsHeader"],
+                    isType: true,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-common/meta",
+                    props: ["MetaPropertyType"],
+                    isType: false,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-common/meta",
+                    props: ["MetaPropertyDataWoType"],
+                    isType: true,
+                },
+            ],
+            name: mainData.templateName,
+        };
+        const header = mapAnnotationsHeader(mainData);
+        const json = await formatJson2Spaces(JSON.stringify(header));
+        const lines = json.split("\n");
+        res.code.push(`export const ${names.annotations}: AnnotationsHeader = `);
+        // replace enums and types
+        for (let line of lines) {
+            // type
+            let match = null;
+            match = line.match(typeRegex);
+            while (match && match.length > 1) {
+                line = line.replace(typeRegex, `type: MetaPropertyType.${match[1]}`);
+                match = line.match(typeRegex);
+            }
+            // itemType
+            match = line.match(itemTypeRegex);
+            while (match && match.length > 2) {
+                line = line.replace(itemTypeRegex, `itemType: MetaPropertyType.${match[2]}`);
+                match = line.match(itemTypeRegex);
+            }
+            // propertyRef
+            match = line.match(propertyRefRegex);
+            while (match && match.length > 1) {
+                line = line.replace(propertyRefRegex, `propertyRef: "${match[1]}" as keyof MetaPropertyDataWoType`);
+                match = line.match(propertyRefRegex);
+            }
+            res.code.push(line);
+        }
+        res.code.push(";");
+        return res;
+    }
+}
+export default new GeneratorAnnotations();

package/dist/generator/GeneratorBackend.d.ts

@@ -0,0 +1,13 @@
+import type { MetaNames } from "@mxpicture/gcp-functions-common/types";
+import { MetaHeadData, MetaRoutes } from "@mxpicture/gcp-functions-common/meta";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorBackend extends Generator {
+    constructor();
+    protected runHeader(mainData: MetaHeadData, names: MetaNames): Promise<GeneratorCode | null>;
+    protected buildApi(routes: MetaRoutes, names: MetaNames): string[];
+    protected buildFunction(names: MetaNames): string[];
+    protected buildStore(names: MetaNames): string[];
+    protected buildCreate(names: MetaNames): string[];
+}
+declare const _default: GeneratorBackend;
+export default _default;

package/dist/generator/GeneratorBackend.js

@@ -0,0 +1,134 @@
+import { hasCrudRoute, isCrudRoute, MetaFileExtension, MetaFileType, MetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+import { Generator } from "./Generator.js";
+import { Collector } from "../common/Collector.js";
+import { lowerFirstLetter } from "@mxpicture/gcp-functions-code/common";
+export class GeneratorBackend extends Generator {
+    constructor() {
+        super(MetaFileType.backend, MetaFileExtension.ts, MetaTargetType.backend, Collector.instance(), true);
+    }
+    async runHeader(mainData, names) {
+        if (Object.keys(mainData.routes).length === 0)
+            return null;
+        return {
+            code: [
+                ...this.buildFunction(names),
+                "",
+                ...this.buildApi(mainData.routes, names),
+                "",
+                ...this.buildStore(names),
+                "",
+                ...this.buildCreate(names),
+            ],
+            imports: [
+                {
+                    path: "@mxpicture/gcp-functions-common/types",
+                    props: ["ApiFromRoutes", "FunctionRequest", "FunctionResponse"],
+                    isType: true,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-backend/store",
+                    props: ["Store"],
+                    isType: false,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-backend/validation",
+                    props: ["Validation"],
+                    isType: false,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-backend/api",
+                    props: ["BackendApi"],
+                    isType: false,
+                },
+                {
+                    path: "firebase-admin/firestore",
+                    props: ["FirestoreDataConverter"],
+                    isType: true,
+                },
+                {
+                    path: "firebase-functions/v2/https",
+                    props: ["CallableFunction"],
+                    isType: true,
+                },
+                {
+                    path: this.importCommon(MetaFileType.routes),
+                    props: [names.routes],
+                    isType: true,
+                },
+                {
+                    path: this.importCommon(MetaFileType.doc),
+                    props: [names.doc],
+                    isType: true,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-backend/function",
+                    props: ["IBackendFunction"],
+                    isType: false,
+                },
+                {
+                    path: this.importCommon(MetaFileType.routes),
+                    props: [`${names.routes}Name`],
+                    isType: false,
+                },
+                {
+                    path: this.importBackend(MetaFileType.zod),
+                    props: [names.shape],
+                    isType: false,
+                },
+            ],
+            name: mainData.templateName,
+        };
+    }
+    buildApi(routes, names) {
+        const code = [];
+        const superClassName = hasCrudRoute(Object.keys(routes))
+            ? "BackendApi"
+            : "IBackendApi";
+        code.push(`export abstract class I${names.api} extends ${superClassName}<${names.doc}, ${names.store}, Validation<${names.doc}>>`, `implements ApiFromRoutes<${names.routes}>`, "{", `  public constructor() { super("${lowerFirstLetter(names.basename)}"); }`, "");
+        for (const [routeName, params] of Object.entries(routes)) {
+            if (isCrudRoute(routeName))
+                continue; // ignore crud --> provided by super class
+            let definition = routeName;
+            if (params.requestType !== "never" && params.requestType !== "void")
+                definition += `(request: ${params.requestType})`;
+            else
+                definition += `()`;
+            definition += `: Promise<${params.responseType}>`;
+            code.push(`  public abstract ${definition};`);
+        }
+        code.push("}");
+        return code;
+    }
+    buildFunction(names) {
+        return [
+            `export class ${names.func} extends IBackendFunction<${names.doc}, I${names.api}> {`,
+            `  public constructor(api?: I${names.api}) { super("${names.functionName}"); this.useRoutes(${names.routes}Name); if (api) this.useApi(api); }`,
+            "}",
+        ];
+    }
+    buildStore(names) {
+        return [
+            `export class ${names.store} extends Store<${names.doc}> {`,
+            `  public constructor(converter?: FirestoreDataConverter<${names.doc}>) { super("${lowerFirstLetter(names.basename)}", converter); }`,
+            "}",
+        ];
+    }
+    buildCreate(names) {
+        return [
+            `export const create${names.basename}Function = (api: I${names.api}): CallableFunction<FunctionRequest<unknown>,Promise<FunctionResponse<unknown>>,unknown> => {`,
+            `  const store = new ${names.store}();`,
+            "",
+            `  const val = new Validation<${names.doc}>("${lowerFirstLetter(names.basename)}");`,
+            `  val.useShape(${names.shape});`,
+            "",
+            `  const func = new ${names.func}(api);`,
+            "",
+            "  api.useStore(store);",
+            "  api.useValidation(val);",
+            "",
+            "  return func.buildFunction();",
+            "};",
+        ];
+    }
+}
+export default new GeneratorBackend();

package/dist/generator/GeneratorDoc.d.ts

@@ -0,0 +1,9 @@
+import { MetaHeadData } from "@mxpicture/gcp-functions-common/meta";
+import { MetaNames } from "@mxpicture/gcp-functions-common/types";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorDoc extends Generator {
+    constructor();
+    protected runHeader(mainData: MetaHeadData, names: MetaNames): Promise<GeneratorCode | null>;
+}
+declare const _default: GeneratorDoc;
+export default _default;

package/dist/generator/GeneratorDoc.js

@@ -0,0 +1,22 @@
+import { MetaFileExtension, MetaFileType, MetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+import { Generator } from "./Generator.js";
+import { Collector } from "../common/Collector.js";
+import { metaBasename, isMetaNameType } from "../meta/meta.names.js";
+export class GeneratorDoc extends Generator {
+    constructor() {
+        super(MetaFileType.doc, MetaFileExtension.ts, MetaTargetType.common, Collector.instance());
+    }
+    async runHeader(mainData, names) {
+        const res = {
+            code: [],
+            imports: [],
+            name: mainData.templateName,
+        };
+        res.code.push(`export interface ${names.doc} {`);
+        for (const prop of mainData.properties)
+            res.code.push(`  ${prop.propertyKey}${prop.optional ? "?" : ""}: `, `${metaBasename(prop.propertyType)}${isMetaNameType(prop.propertyType, MetaFileType.template) ? "Doc" : ""};`);
+        res.code.push("}");
+        return res;
+    }
+}
+export default new GeneratorDoc();

package/dist/generator/GeneratorFrontend.d.ts

@@ -0,0 +1,12 @@
+import { MetaHeadData, MetaRoutes } from "@mxpicture/gcp-functions-common/meta";
+import { MetaNames } from "@mxpicture/gcp-functions-common/types";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorFrontend extends Generator {
+    constructor();
+    protected runHeader(mainData: MetaHeadData, names: MetaNames): Promise<GeneratorCode | null>;
+    protected buildApi(routes: MetaRoutes, names: MetaNames): string[];
+    protected buildFunction(names: MetaNames): string[];
+    protected buildCreate(names: MetaNames): string[];
+}
+declare const _default: GeneratorFrontend;
+export default _default;

package/dist/generator/GeneratorFrontend.js

@@ -0,0 +1,94 @@
+import { hasCrudRoute, isCrudRoute, MetaFileExtension, MetaFileType, MetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+import { Generator } from "./Generator.js";
+import { Collector } from "../common/Collector.js";
+import { lowerFirstLetter } from "@mxpicture/gcp-functions-code/common";
+export class GeneratorFrontend extends Generator {
+    constructor() {
+        super(MetaFileType.frontend, MetaFileExtension.ts, MetaTargetType.frontend, Collector.instance(), true);
+    }
+    async runHeader(mainData, names) {
+        if (Object.keys(mainData.routes).length === 0)
+            return null;
+        return {
+            code: [
+                ...this.buildFunction(names),
+                "",
+                ...this.buildApi(mainData.routes, names),
+                "",
+                ...this.buildCreate(names),
+            ],
+            imports: [
+                {
+                    path: "@mxpicture/gcp-functions-frontend/function",
+                    props: ["IFrontendFunction"],
+                    isType: false,
+                },
+                {
+                    path: this.importCommon(MetaFileType.routes),
+                    props: [`${names.routes}Name`],
+                    isType: false,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-frontend/api",
+                    props: ["FrontendApi"],
+                    isType: false,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-common/types",
+                    props: ["ApiFromRoutes"],
+                    isType: true,
+                },
+                {
+                    path: this.importCommon(MetaFileType.routes),
+                    props: [names.routes],
+                    isType: true,
+                },
+                {
+                    path: this.importCommon(MetaFileType.doc),
+                    props: [names.doc],
+                    isType: true,
+                },
+            ],
+            name: mainData.templateName,
+        };
+    }
+    buildApi(routes, names) {
+        const code = [];
+        const superClassName = hasCrudRoute(Object.keys(routes))
+            ? `FrontendApi<${names.doc}, ${names.func}>`
+            : `IFrontendApi<${names.func}>`;
+        code.push(`export class ${names.api} extends ${superClassName}`, `implements ApiFromRoutes<${names.routes}>`, "{", `public constructor(func?: ${names.func}) { super("${names.functionName}"); if (func) this.useFunc(func); }`, "");
+        for (const [routeName, params] of Object.entries(routes)) {
+            if (isCrudRoute(routeName))
+                continue; // ignore crud --> provided by super class
+            let definition = routeName;
+            if (params.requestType !== "never" && params.requestType !== "void")
+                definition += `(request: ${params.requestType})`;
+            else
+                definition += `()`;
+            definition += `: Promise<${params.responseType}>`;
+            code.push(` public async ${definition} {`, `   return (await this.func().outgress({ route: "${routeName}", data: request })).data as ${params.responseType};`, " }", "");
+        }
+        code.push("}");
+        return code;
+    }
+    buildFunction(names) {
+        return [
+            `export class ${names.func} extends IFrontendFunction {`,
+            `  public constructor() { super("${lowerFirstLetter(names.basename)}"); this.useRoutes(${names.routes}Name); }`,
+            "}",
+        ];
+    }
+    buildCreate(names) {
+        return [
+            `export const create${names.basename}Api = () => {`,
+            `  const func = new ${names.func}();`,
+            `  const api = new ${names.api}(func);`,
+            "  return api;",
+            "};",
+            "",
+            `export const ${lowerFirstLetter(names.basename)}Api = create${names.basename}Api();`,
+        ];
+    }
+}
+export default new GeneratorFrontend();

package/dist/generator/GeneratorRoutes.d.ts

@@ -0,0 +1,11 @@
+import { MetaHeadData } from "@mxpicture/gcp-functions-common/meta";
+import { MetaNames } from "@mxpicture/gcp-functions-common/types";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorRoutes extends Generator {
+    constructor();
+    protected runHeader(mainData: MetaHeadData, names: MetaNames): Promise<GeneratorCode | null>;
+    protected buildType(res: GeneratorCode, names: MetaNames, mainData: MetaHeadData): void;
+    protected buildEnum(res: GeneratorCode, names: MetaNames, mainData: MetaHeadData): void;
+}
+declare const _default: GeneratorRoutes;
+export default _default;

package/dist/generator/GeneratorRoutes.js

@@ -0,0 +1,52 @@
+import { MetaFileExtension, MetaFileType, MetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+import { Generator } from "./Generator.js";
+import { Collector } from "../common/Collector.js";
+export class GeneratorRoutes extends Generator {
+    constructor() {
+        super(MetaFileType.routes, MetaFileExtension.ts, MetaTargetType.common, Collector.instance());
+    }
+    async runHeader(mainData, names) {
+        if (Object.keys(mainData.routes).length === 0)
+            return null;
+        const res = {
+            code: [],
+            imports: [
+                {
+                    path: "@mxpicture/gcp-functions-common/types",
+                    isType: true,
+                    props: [
+                        "ApiFilter",
+                        "DocumentKey",
+                        "RouteDef",
+                        "WithKey",
+                        "WithoutKey",
+                        "WithRoutes",
+                    ],
+                },
+                {
+                    path: this.importCommon(MetaFileType.doc),
+                    isType: true,
+                    props: [names.doc],
+                },
+            ],
+            name: mainData.templateName,
+        };
+        this.buildType(res, names, mainData);
+        res.code.push("");
+        this.buildEnum(res, names, mainData);
+        return res;
+    }
+    buildType(res, names, mainData) {
+        res.code.push(`export type ${names.routes} = WithRoutes<{`);
+        for (const [routeName, params] of Object.entries(mainData.routes))
+            res.code.push(`  ${routeName}: RouteDef<${params.requestType}, ${params.responseType}>;`);
+        res.code.push("}>;");
+    }
+    buildEnum(res, names, mainData) {
+        res.code.push(`export enum ${names.routes}Name {`);
+        for (const routeName of Object.keys(mainData.routes))
+            res.code.push(`  ${routeName} = "${routeName}",`);
+        res.code.push("}");
+    }
+}
+export default new GeneratorRoutes();

package/dist/generator/GeneratorZod.d.ts

@@ -0,0 +1,25 @@
+import { MetaHeadData, MetaPropertyData } from "@mxpicture/gcp-functions-common/meta";
+import { MetaImport, MetaNames } from "@mxpicture/gcp-functions-common/types";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorZod extends Generator {
+    protected zImports: Set<string>;
+    constructor();
+    protected runHeader(mainData: MetaHeadData, names: MetaNames): Promise<GeneratorCode | null>;
+    protected startZ(): void;
+    protected endZ(): MetaImport[];
+    protected z(name: string, params?: string): string;
+    protected buildShape(properties: MetaPropertyData[], names: MetaNames): string[];
+    protected buildSchema(names: MetaNames): string[];
+    protected buildProperty(prop: MetaPropertyData): string | null;
+    protected buildNumber(_prop: MetaPropertyData): string | null;
+    protected buildKey(_prop: MetaPropertyData): string | null;
+    protected buildCreateTime(_prop: MetaPropertyData): string | null;
+    protected buildUpdateTime(_prop: MetaPropertyData): string | null;
+    protected buildString(_prop: MetaPropertyData): string | null;
+    protected buildArray(_prop: MetaPropertyData): string | null;
+    protected buildObject(_prop: MetaPropertyData): string | null;
+    protected buildDate(_prop: MetaPropertyData): string | null;
+    protected buildBoolean(_prop: MetaPropertyData): string | null;
+}
+declare const _default: GeneratorZod;
+export default _default;