@mxpicture/gcp-functions-generator 0.2.0

package/dist/generator/GeneratorZod.js

@@ -0,0 +1,149 @@
+import { castMetaPropertyArray, castMetaPropertyBoolean, castMetaPropertyCreateTime, castMetaPropertyDate, castMetaPropertyKey, castMetaPropertyNumber, castMetaPropertyObject, castMetaPropertyString, castMetaPropertyUpdateTime, MetaFileExtension, MetaFileType, MetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+import { Generator } from "./Generator.js";
+import { Collector } from "../common/Collector.js";
+export class GeneratorZod extends Generator {
+    zImports = new Set();
+    constructor() {
+        super(MetaFileType.zod, MetaFileExtension.ts, MetaTargetType.backend, Collector.instance());
+    }
+    async runHeader(mainData, names) {
+        if (mainData.properties.length === 0)
+            return null;
+        this.startZ();
+        const code = [
+            ...this.buildShape(mainData.properties, names),
+            "",
+            ...this.buildSchema(names),
+        ];
+        return {
+            code,
+            imports: this.endZ(),
+            name: mainData.templateName,
+        };
+    }
+    startZ() {
+        this.zImports = new Set();
+    }
+    endZ() {
+        if (this.zImports.size === 0)
+            return [];
+        const results = [
+            {
+                props: [...this.zImports],
+                path: "zod",
+            },
+        ];
+        this.zImports = new Set();
+        return results;
+    }
+    z(name, params = "()") {
+        this.zImports.add(name);
+        return name + params;
+    }
+    buildShape(properties, names) {
+        const code = [];
+        code.push(`export const ${names.shape} = {`);
+        for (const prop of properties) {
+            let line = this.buildProperty(prop);
+            if (prop.optional)
+                line += ".optional()";
+            code.push(`  ${prop.propertyKey}: ${line},`);
+        }
+        code.push("};");
+        return code;
+    }
+    buildSchema(names) {
+        return [
+            `export const ${names.schema} = ${this.z("object", `(${names.shape})`)};`,
+        ];
+    }
+    buildProperty(prop) {
+        return (this.buildNumber(prop) ??
+            this.buildKey(prop) ??
+            this.buildCreateTime(prop) ??
+            this.buildUpdateTime(prop) ??
+            this.buildString(prop) ??
+            this.buildArray(prop) ??
+            this.buildObject(prop) ??
+            this.buildDate(prop) ??
+            this.buildBoolean(prop));
+    }
+    buildNumber(_prop) {
+        const prop = castMetaPropertyNumber(_prop);
+        if (!prop)
+            return null;
+        // todo   format?: MetaNumberFormat;
+        let line = this.z("number");
+        if (prop.min !== undefined)
+            line += `.${prop.minInclusive ? "gte" : "gt"}(${prop.min})`;
+        if (prop.max !== undefined)
+            line += `.${prop.maxInclusive ? "lte" : "lt"}(${prop.max})`;
+        if (prop.multipleOf !== undefined)
+            line += `.multipleOf(${prop.multipleOf})`;
+        return line;
+    }
+    buildKey(_prop) {
+        const prop = castMetaPropertyKey(_prop);
+        if (!prop)
+            return null;
+        return this.z("string");
+    }
+    buildCreateTime(_prop) {
+        const prop = castMetaPropertyCreateTime(_prop);
+        if (!prop)
+            return null;
+        return this.z("date");
+    }
+    buildUpdateTime(_prop) {
+        const prop = castMetaPropertyUpdateTime(_prop);
+        if (!prop)
+            return null;
+        return this.z("date");
+    }
+    buildString(_prop) {
+        const prop = castMetaPropertyString(_prop);
+        if (!prop)
+            return null;
+        // todo   format?: MetaStringFormat;
+        let line = this.z("string");
+        if (prop.minLength !== undefined || prop.exactLength !== undefined)
+            line += `.min(${prop.minLength ?? prop.exactLength})`;
+        if (prop.maxLength !== undefined || prop.exactLength !== undefined)
+            line += `.max(${prop.maxLength ?? prop.exactLength})`;
+        if (prop.regex !== undefined)
+            line += `.regex(${prop.regex})`;
+        return line;
+    }
+    buildArray(_prop) {
+        const prop = castMetaPropertyArray(_prop);
+        if (!prop)
+            return null;
+        let propertyType = _prop.propertyType.endsWith("[]")
+            ? _prop.propertyType.substring(0, _prop.propertyType.length - "[]".length)
+            : _prop.propertyType;
+        propertyType =
+            this.collector.findFirst(propertyType)?.data.names.schema ??
+                `${propertyType}()`;
+        return `${this.z("array", `(${propertyType})`)}`;
+    }
+    buildObject(_prop) {
+        const prop = castMetaPropertyObject(_prop);
+        if (!prop)
+            return null;
+        return (this.collector.findFirst(_prop.propertyType)?.data.names.schema ??
+            _prop.propertyType);
+    }
+    buildDate(_prop) {
+        const prop = castMetaPropertyDate(_prop);
+        if (!prop)
+            return null;
+        return this.z("date");
+    }
+    buildBoolean(_prop) {
+        const prop = castMetaPropertyBoolean(_prop);
+        if (!prop)
+            return null;
+        return this.z("boolean");
+    }
+}
+export default new GeneratorZod();

package/dist/generator/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Generator.js";
+export * from "./GeneratorAnnotations.js";
+export * from "./GeneratorBackend.js";
+export * from "./GeneratorDoc.js";
+export * from "./GeneratorFrontend.js";
+export * from "./GeneratorRoutes.js";
+export * from "./GeneratorZod.js";

package/dist/generator/index.js

@@ -0,0 +1,8 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./Generator.js";
+export * from "./GeneratorAnnotations.js";
+export * from "./GeneratorBackend.js";
+export * from "./GeneratorDoc.js";
+export * from "./GeneratorFrontend.js";
+export * from "./GeneratorRoutes.js";
+export * from "./GeneratorZod.js";

package/dist/meta/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./meta.decorators.js";
+export * from "./meta.imports.js";
+export * from "./meta.names.js";

package/dist/meta/index.js

@@ -0,0 +1,4 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./meta.decorators.js";
+export * from "./meta.imports.js";
+export * from "./meta.names.js";

package/dist/meta/meta.decorators.d.ts

@@ -0,0 +1,26 @@
+import type { WithoutType } from "@mxpicture/gcp-functions-common/types";
+import { MetaHeadDecorator, MetaPropertyDecorator } from "@mxpicture/gcp-functions-common/meta";
+import { MetaInterfaceOptions, MetaHeadInterfaceOptions, MetaKeyOptions, MetaCreateTimeOptions, MetaUpdateTimeOptions, MetaNumberOptions, MetaStringOptions, MetaArrayOptions, MetaObjectOptions, MetaDateOptions, MetaBooleanOptions } from "@mxpicture/gcp-functions-common/types";
+export declare const MetaInterface: (options: WithoutType<MetaInterfaceOptions>, decoratorType?: MetaHeadDecorator.MetaInterface) => <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => T;
+export declare const MetaHeadInterface: (options: WithoutType<MetaHeadInterfaceOptions>, decoratorType?: MetaHeadDecorator.MetaHeadInterface) => <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => T;
+export declare const MetaKey: (options: Omit<WithoutType<MetaKeyOptions>, "optional">, decoratorType?: MetaPropertyDecorator.MetaKey) => (target: any, propertyKey: string) => void;
+export type MetaCreateTimeOptionsBase = WithoutType<MetaCreateTimeOptions>;
+export declare const MetaCreateTime: <Opt extends MetaCreateTimeOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaCreateTime) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? Date | undefined : Date) ? unknown : never)) => void;
+export type MetaUpdateTimeOptionsBase = WithoutType<MetaUpdateTimeOptions>;
+export declare const MetaUpdateTime: <Opt extends MetaUpdateTimeOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaUpdateTime) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? Date | undefined : Date) ? unknown : never)) => void;
+export type MetaNumberOptionsBase = WithoutType<MetaNumberOptions>;
+export declare const MetaNumber: <Opt extends MetaNumberOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaNumber) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? number | undefined : number) ? unknown : never)) => void;
+export type MetaStringOptionsBase = WithoutType<MetaStringOptions>;
+export declare const MetaString: <Opt extends MetaStringOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaString) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? string | undefined : string) ? unknown : never)) => void;
+export type MetaArrayOptionsBase = WithoutType<MetaArrayOptions>;
+export declare const MetaArray: <Opt extends MetaArrayOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaArray) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? unknown[] | undefined : unknown[]) ? unknown : never)) => void;
+export type MetaObjectOptionsBase = WithoutType<MetaObjectOptions>;
+export declare const MetaObject: <Opt extends MetaObjectOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaObject) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? object | undefined : object) ? unknown : never)) => void;
+export type MetaDateOptionsBase = WithoutType<MetaDateOptions>;
+export declare const MetaDate: <Opt extends MetaDateOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaDate) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? Date | undefined : Date) ? unknown : never)) => void;
+export type MetaBooleanOptionsBase = WithoutType<MetaBooleanOptions>;
+export declare const MetaBoolean: <Opt extends MetaBooleanOptionsBase>(options: Opt, decoratorType?: MetaPropertyDecorator.MetaBoolean) => <T, K extends Extract<keyof T, string>>(target: T, propertyKey: K & (T[K] extends (Opt["optional"] extends true ? boolean | undefined : boolean) ? unknown : never)) => void;

package/dist/meta/meta.decorators.js

@@ -0,0 +1,17 @@
+import { MetaHeadDecorator, MetaPropertyDecorator, } from "@mxpicture/gcp-functions-common/meta";
+// after adding new decorator add it to MetaPropDecorator too
+export const MetaInterface = (options, decoratorType = MetaHeadDecorator.MetaInterface) => (constructor) => {
+    return constructor;
+};
+export const MetaHeadInterface = (options, decoratorType = MetaHeadDecorator.MetaHeadInterface) => (constructor) => {
+    return constructor;
+};
+export const MetaKey = (options, decoratorType = MetaPropertyDecorator.MetaKey) => (target, propertyKey) => { };
+export const MetaCreateTime = (options, decoratorType = MetaPropertyDecorator.MetaCreateTime) => (target, propertyKey) => { };
+export const MetaUpdateTime = (options, decoratorType = MetaPropertyDecorator.MetaUpdateTime) => (target, propertyKey) => { };
+export const MetaNumber = (options, decoratorType = MetaPropertyDecorator.MetaNumber) => (target, propertyKey) => { };
+export const MetaString = (options, decoratorType = MetaPropertyDecorator.MetaString) => (target, propertyKey) => { };
+export const MetaArray = (options, decoratorType = MetaPropertyDecorator.MetaArray) => (target, propertyKey) => { };
+export const MetaObject = (options, decoratorType = MetaPropertyDecorator.MetaObject) => (target, propertyKey) => { };
+export const MetaDate = (options, decoratorType = MetaPropertyDecorator.MetaDate) => (target, propertyKey) => { };
+export const MetaBoolean = (options, decoratorType = MetaPropertyDecorator.MetaBoolean) => (target, propertyKey) => { };

package/dist/meta/meta.imports.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+import { MetaImport } from "@mxpicture/gcp-functions-common/types";
+export interface ExtractedImport {
+    module: string;
+    defaultImport?: string;
+    namedImports?: string[];
+    namespaceImport?: string;
+    isTypeOnly?: boolean;
+}
+export declare const extractNamedImports: (sourceFile: ts.SourceFile | string) => MetaImport[];
+export declare const extractImports: (sourceFile: ts.SourceFile) => ExtractedImport[];

package/dist/meta/meta.imports.js

@@ -0,0 +1,54 @@
+import ts from "typescript";
+import { createSourceFiles } from "@mxpicture/gcp-functions-code/common";
+export const extractNamedImports = (sourceFile) => {
+    if (typeof sourceFile === "string") {
+        const files = createSourceFiles([sourceFile]);
+        if (files.length === 0)
+            return [];
+        sourceFile = files[0].sourceFile;
+    }
+    const results = [];
+    const imports = extractImports(sourceFile);
+    for (const imp of imports) {
+        if (!imp.namedImports || imp.namedImports.length === 0)
+            continue;
+        results.push({
+            path: imp.module,
+            props: [...imp.namedImports],
+            isType: imp.isTypeOnly,
+        });
+    }
+    return results;
+};
+export const extractImports = (sourceFile) => {
+    const imports = [];
+    sourceFile.forEachChild((node) => {
+        if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
+            const moduleName = node.moduleSpecifier.text;
+            let defaultImport;
+            let namedImports = [];
+            let namespaceImport;
+            if (!node.importClause)
+                return;
+            if (node.importClause.name)
+                defaultImport = node.importClause.name.text;
+            const isTypeOnly = node.importClause.phaseModifier === ts.SyntaxKind.TypeKeyword;
+            if (node.importClause.namedBindings) {
+                if (ts.isNamedImports(node.importClause.namedBindings)) {
+                    namedImports = node.importClause.namedBindings.elements.map((el) => el.name.text);
+                }
+                else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+                    namespaceImport = node.importClause.namedBindings.name.text;
+                }
+            }
+            imports.push({
+                module: moduleName,
+                defaultImport,
+                namedImports: namedImports.length ? namedImports : undefined,
+                namespaceImport,
+                isTypeOnly,
+            });
+        }
+    });
+    return imports;
+};

package/dist/meta/meta.names.d.ts

@@ -0,0 +1,13 @@
+import { MetaFileType, MetaTargetType } from "@mxpicture/gcp-functions-common/meta";
+import type { MetaNames } from "@mxpicture/gcp-functions-common/types";
+export declare const metaRename: (name: string, type: MetaFileType | string) => string;
+export declare const metaRenameAsync: (name: string, type: MetaFileType | string) => Promise<string>;
+export declare const metaBasename: (name: string) => string;
+export declare const metaBasenameAsync: (name: string) => Promise<string>;
+export declare const isMetaNameType: (name: string, type: MetaFileType) => boolean;
+export declare const metaNames: (basename: string, prefix?: string, apiType?: string, funcType?: string, targetType?: MetaTargetType) => MetaNames;
+export declare const metaNamesAsync: (basename: string, prefix?: string, apiType?: string, funcType?: string, targetType?: MetaTargetType) => Promise<MetaNames>;
+export declare const metaFrontendNames: (basename: string, prefix?: string) => MetaNames;
+export declare const metaFrontendNamesAsync: (basename: string, prefix?: string) => Promise<MetaNames>;
+export declare const metaBackendNames: (basename: string, prefix?: string) => MetaNames;
+export declare const metaBackendNamesAsync: (basename: string, prefix?: string) => Promise<MetaNames>;

package/dist/meta/meta.names.js

@@ -0,0 +1,93 @@
+import { MetaFileType, MetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+import { lowerFirstLetter, lowerFirstLetterAsync, upperFirstLetter, upperFirstLetterAsync, } from "@mxpicture/gcp-functions-code/common";
+export const metaRename = (name, type) => `${metaBasename(name)}${upperFirstLetter(type)}`;
+export const metaRenameAsync = async (name, type) => {
+    const [n, t] = await Promise.all([
+        metaBasenameAsync(name),
+        upperFirstLetterAsync(type),
+    ]);
+    return `${n}${t}`;
+};
+export const metaBasename = (name) => {
+    for (const type of Object.values(MetaFileType)) {
+        if (isMetaNameType(name, type))
+            return `${name.substring(0, name.length - type.length)}`;
+    }
+    return name.substring(0);
+};
+export const metaBasenameAsync = async (name) => Promise.resolve().then(() => metaBasename(name));
+export const isMetaNameType = (name, type) => name.endsWith(upperFirstLetter(type));
+export const metaNames = (basename, prefix, apiType, funcType, targetType) => {
+    const basenameLower = lowerFirstLetter(basename);
+    const basenameUpper = upperFirstLetter(basename);
+    return {
+        basename,
+        basenameLower,
+        basenameUpper,
+        targetType: targetType ?? MetaTargetType.common,
+        template: metaRename(basename, MetaFileType.template),
+        doc: metaRename(basename, MetaFileType.doc),
+        routes: metaRename(basename, MetaFileType.routes),
+        api: apiType ?? "",
+        func: funcType ?? "",
+        store: metaRename(basename, "store"),
+        shape: lowerFirstLetter(metaRename(basename, "shape")),
+        schema: lowerFirstLetter(metaRename(basename, "schema")),
+        annotations: lowerFirstLetter(metaRename(basename, "annotations")),
+        functionName: prefix
+            ? `${lowerFirstLetter(prefix)}${basenameUpper}`
+            : basenameLower,
+    };
+};
+// export const processMetaBasenames = async (
+//   names: string[],
+//   concurrency = 50,
+// ): Promise<string[]> => {
+//   const pLimit = (await import("p-limit")).default;
+//   const limit = pLimit(concurrency);
+//   return Promise.all(
+//     names.map((name) => limit(async () => metaBasename(name))),
+//   );
+// };
+export const metaNamesAsync = async (basename, prefix, apiType, funcType, targetType) => {
+    const [basenameLower, basenameUpper, template, doc, routes, store, shapeRaw, schemaRaw, annotationsRaw, prefixLower, api, func,] = await Promise.all([
+        lowerFirstLetterAsync(basename),
+        upperFirstLetterAsync(basename),
+        metaRenameAsync(basename, MetaFileType.template),
+        metaRenameAsync(basename, MetaFileType.doc),
+        metaRenameAsync(basename, MetaFileType.routes),
+        metaRenameAsync(basename, "store"),
+        metaRenameAsync(basename, "shape"),
+        metaRenameAsync(basename, "schema"),
+        metaRenameAsync(basename, "annotations"),
+        Promise.resolve().then(async () => prefix ? lowerFirstLetterAsync(prefix) : null),
+        Promise.resolve().then(async () => apiType ? metaRenameAsync(basename, apiType) : ""),
+        Promise.resolve().then(async () => funcType ? metaRenameAsync(basename, funcType) : ""),
+    ]);
+    const [shape, schema, annotations, functionName] = await Promise.all([
+        lowerFirstLetterAsync(shapeRaw),
+        lowerFirstLetterAsync(schemaRaw),
+        lowerFirstLetterAsync(annotationsRaw),
+        Promise.resolve().then(() => prefixLower ? `${prefixLower}${basenameUpper}` : basenameLower),
+    ]);
+    return {
+        basename,
+        basenameLower,
+        basenameUpper,
+        targetType: targetType ?? MetaTargetType.common,
+        template,
+        doc,
+        routes,
+        api,
+        func,
+        store,
+        shape,
+        schema,
+        annotations,
+        functionName,
+    };
+};
+export const metaFrontendNames = (basename, prefix) => metaNames(basename, prefix, "feApi", "feFunction", MetaTargetType.frontend);
+export const metaFrontendNamesAsync = async (basename, prefix) => metaNamesAsync(basename, prefix, "feApi", "feFunction", MetaTargetType.frontend);
+export const metaBackendNames = (basename, prefix) => metaNames(basename, prefix, "beApi", "beFunction", MetaTargetType.backend);
+export const metaBackendNamesAsync = async (basename, prefix) => metaNamesAsync(basename, prefix, "beApi", "beFunction", MetaTargetType.backend);

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@mxpicture/gcp-functions-generator",
+  "version": "0.2.0",
+  "description": "Tools for google cloud functions",
+  "type": "module",
+  "author": "MXPicture",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MXPicture/npm-gcp-functions.git"
+  },
+  "exports": {
+    "./common": "./dist/common/index.js",
+    "./generator": "./dist/generator/index.js",
+    "./meta": "./dist/meta/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "clean": "rm -rf dist .tsbuildinfo tsconfig.tsbuildinfo node_modules",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" --ext .ts,.tsx",
+    "build": "tsc -b .",
+    "test": "vitest run",
+    "test:clean": "rm -rf src/4testing/generator-test-*",
+    "run:test": "pnpm exec tsx src/scripts/test.mts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@mxpicture/gcp-functions-common": "^0.2.0",
+    "@mxpicture/gcp-functions-code": "^0.2.0",
+    "@mxpicture/gcp-functions-backend": "^0.2.0",
+    "@mxpicture/gcp-functions-frontend": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.0",
+    "eslint": "^9.39.2",
+    "execa": "^9.6.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}