@mxpicture/gcp-functions-backend 0.1.53 → 0.1.55

package/dist/change/ChangeHandler.d.ts

@@ -0,0 +1,13 @@
+import { ChangedHistory, ChangedResult, GitChangedContentsResult } from "./types.change.js";
+import { GeneratorResultFile } from "../generator/Generator.js";
+export declare class ChangeHandler {
+    protected _history: ChangedHistory | null;
+    constructor();
+    history(): Promise<ChangedHistory>;
+    writeHistory(): Promise<ChangedHistory | null>;
+    readChanges(sinceCommit?: string): Promise<GitChangedContentsResult>;
+    runGeneration(result: ChangedResult): GeneratorResultFile[];
+    writeFiles(files: GeneratorResultFile[]): Promise<void>;
+    buildTriggers(gitResult: GitChangedContentsResult): Promise<ChangedResult>;
+    commitChanges(): Promise<void>;
+}

package/dist/change/ChangeHandler.js

@@ -0,0 +1,143 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { formatJson, templatesPathRead } from "../meta/meta.common.js";
+import { GitChanges } from "./GitChanges.js";
+import pkg from "json5";
+import { changedHistorySchema, } from "./types.change.js";
+import micromatch from "micromatch";
+import { extract, createExtractors } from "../generatorCommon/Extractor.js";
+import { Generator } from "../generator/Generator.js";
+import { createGenerators } from "../generatorCommon/generator.common.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const historyJsonDir = resolve(__dirname, "../../");
+const historyJsonPath = join(historyJsonDir, "./history.json");
+// export const execAsync = async (
+//   command: string,
+//   options?: ExecOptionsWithStringEncoding,
+// ): Promise<string> =>
+//   new Promise<string>(async (resolve, reject) =>
+//     exec(command, options ?? {}, (error, stdout, stderr) =>
+//       error ? reject(stderr) : resolve(stdout),
+//     ),
+//   );
+export class ChangeHandler {
+    _history = null;
+    constructor() { }
+    async history() {
+        if (this._history)
+            return this._history;
+        const content = await readFile(historyJsonPath, "utf8");
+        this._history = pkg.parse(content);
+        this._history = await changedHistorySchema.parseAsync(this._history);
+        return this._history;
+    }
+    async writeHistory() {
+        if (!this._history)
+            return null;
+        await mkdir(historyJsonDir, { recursive: true });
+        await writeFile(historyJsonPath, await formatJson(pkg.stringify(this._history)));
+        return this._history;
+    }
+    async readChanges(sinceCommit) {
+        const git = new GitChanges();
+        sinceCommit ??= (await this.history()).lastCommitHash;
+        if (!sinceCommit)
+            throw new Error("No commit hash found or provided");
+        return await git.readChangedFilesSince(sinceCommit);
+    }
+    runGeneration(result) {
+        // collect runners
+        const runners = [];
+        for (const trigger of result.triggers) {
+            for (const generator of trigger.generators) {
+                let foundRunner = runners.find((runner) => runner.gen === generator.gen);
+                if (!foundRunner) {
+                    foundRunner = { gen: generator.gen, templateFiles: [] };
+                    runners.push(foundRunner);
+                }
+                foundRunner.templateFiles.push(trigger.templateFile);
+            }
+        }
+        // run
+        const results = [];
+        for (const runner of runners)
+            results.push(...runner.gen.run(runner.templateFiles));
+        return results;
+    }
+    async writeFiles(files) {
+        return Generator.write(files);
+    }
+    async buildTriggers(gitResult) {
+        const changed = { ...gitResult, triggers: [] };
+        const generators = await createGenerators();
+        const addTrigger = (...trs) => {
+            for (const tr of trs) {
+                if (!changed.triggers.find((t) => t.templateFile.inputFilePath === tr.templateFile.inputFilePath))
+                    changed.triggers.push(tr);
+            }
+        };
+        const templateFilePaths = await templatesPathRead();
+        const templates = extract(createExtractors(templateFilePaths));
+        for (const changedFile of changed.files) {
+            // check templates
+            const foundTemplate = templates.find((m) => m.repoInputFilePath === changedFile.repoFilePath);
+            if (foundTemplate) {
+                // add all generators
+                addTrigger({
+                    generators,
+                    templateFile: foundTemplate,
+                });
+                continue;
+            }
+            // check super generator
+            if (changedFile.repoFilePath ===
+                "gen/generator/src/generator/Generator.ts" ||
+                changedFile.repoFilePath === "gen/generator/src/generator/index.ts") {
+                // add all generators to all templates
+                addTrigger(...templates.map((templ) => ({
+                    generators,
+                    templateFile: templ,
+                })));
+                continue;
+            }
+            // check generators
+            if (micromatch.isMatch(changedFile.repoFilePath, "gen/generator/**")) {
+                const foundGen = generators.find((generator) => generator.filePath === changedFile.absFilePath);
+                if (foundGen) {
+                    addTrigger(...templates.map((templ) => ({
+                        generators: [foundGen],
+                        templateFile: templ,
+                    })));
+                }
+                else {
+                    addTrigger(...templates.map((templ) => ({
+                        generators,
+                        templateFile: templ,
+                    })));
+                }
+                continue;
+            }
+            // check shared
+            if (micromatch.isMatch(changedFile.repoFilePath, "shared/**")) {
+                addTrigger(...templates.map((templ) => ({
+                    generators,
+                    templateFile: templ,
+                })));
+                continue;
+            }
+        }
+        return changed;
+    }
+    async commitChanges() {
+        const git = new GitChanges();
+        const [hash, hist] = await Promise.all([
+            git.lastCommitHash(),
+            this.history(),
+        ]);
+        if (!hash)
+            throw new Error("No last hash found");
+        hist.lastCommitHash = hash;
+        await this.writeHistory();
+    }
+}

package/dist/change/GitChanges.d.ts

@@ -0,0 +1,34 @@
+import type { SimpleGit } from "simple-git";
+import { GitChangedResult, GitChangedContentsResult } from "./types.change.js";
+export declare class GitChanges {
+    readonly rootDir: string;
+    constructor();
+    /**
+     * Checks if a specific file or directory has been changed since a given git commit.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @returns A result object indicating whether changes were detected.
+     */
+    hasChangedSince(path: string, sinceCommit: string): Promise<GitChangedResult>;
+    /**
+     * Reads the current content of all files that have changed since a given git commit
+     * within a specific file or directory scope.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * Deleted files are excluded from the result since they no longer exist on disk.
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @param cwd - The working directory of the git repository (defaults to process.cwd()).
+     * @returns A result object containing the current content of each changed file.
+     */
+    readChangedFilesSince(sinceCommit: string, readContent?: boolean): Promise<GitChangedContentsResult>;
+    /**
+     * Creates a SimpleGit instance and verifies the cwd is a repo
+     * and the commit ref is valid.
+     */
+    verifiedGit(commitRef?: string): Promise<SimpleGit>;
+    lastCommitHash(): Promise<string | null>;
+}

package/dist/change/GitChanges.js

@@ -0,0 +1,91 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { simpleGit } from "simple-git";
+import { VSCodeWorkspace } from "../vscode/VSCodeWorkspace.js";
+export class GitChanges {
+    rootDir;
+    constructor() {
+        this.rootDir = VSCodeWorkspace.load().getRoot();
+    }
+    /**
+     * Checks if a specific file or directory has been changed since a given git commit.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @returns A result object indicating whether changes were detected.
+     */
+    async hasChangedSince(path, sinceCommit) {
+        const resolvedTarget = resolve(this.rootDir, path);
+        if (!existsSync(resolvedTarget)) {
+            throw new Error(`Target path does not exist: ${resolvedTarget}`);
+        }
+        const git = await this.verifiedGit(sinceCommit);
+        // Compare commit to working directory (includes uncommitted changes)
+        const diff = await git.diffSummary([sinceCommit, "--", path]);
+        const changedFiles = diff.files.map((file) => file.file);
+        return {
+            path,
+            sinceCommit,
+            hasChanged: changedFiles.length > 0,
+            changedFiles,
+        };
+    }
+    /**
+     * Reads the current content of all files that have changed since a given git commit
+     * within a specific file or directory scope.
+     * Includes both committed and uncommitted changes (staged + unstaged).
+     *
+     * Deleted files are excluded from the result since they no longer exist on disk.
+     *
+     * @param target - Relative path to the file or directory to check.
+     * @param sinceCommit - The git commit hash (or ref like a tag/branch) to compare against.
+     * @param cwd - The working directory of the git repository (defaults to process.cwd()).
+     * @returns A result object containing the current content of each changed file.
+     */
+    async readChangedFilesSince(sinceCommit, readContent) {
+        const git = await this.verifiedGit(sinceCommit);
+        // Compare commit to working directory (includes uncommitted changes)
+        const diff = await git.diffSummary([sinceCommit, "--", this.rootDir]);
+        const files = [];
+        for (const entry of diff.files) {
+            const repoFilePath = entry.file;
+            const absFilePath = resolve(this.rootDir, repoFilePath);
+            // Skip deleted files — they no longer exist on disk
+            if (!existsSync(absFilePath)) {
+                continue;
+            }
+            // Read from the file system to capture uncommitted changes
+            const content = readContent ? await readFile(absFilePath, "utf-8") : null;
+            files.push({ absFilePath, content, repoFilePath });
+        }
+        return {
+            path: this.rootDir,
+            sinceCommit,
+            files,
+        };
+    }
+    /**
+     * Creates a SimpleGit instance and verifies the cwd is a repo
+     * and the commit ref is valid.
+     */
+    async verifiedGit(commitRef) {
+        const git = simpleGit(this.rootDir);
+        if (!(await git.checkIsRepo()))
+            throw new Error(`Not a git repository: ${this.rootDir}`);
+        if (!commitRef)
+            return git;
+        try {
+            await git.revparse(["--verify", commitRef]);
+        }
+        catch {
+            throw new Error(`Invalid git commit reference: "${commitRef}"`);
+        }
+        return git;
+    }
+    async lastCommitHash() {
+        const git = await this.verifiedGit();
+        return (await git.log()).latest?.hash ?? null;
+    }
+}

package/dist/change/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ChangeHandler.js";
+export * from "./GitChanges.js";
+export * from "./types.change.js";

package/dist/change/index.js

@@ -0,0 +1,3 @@
+export * from "./ChangeHandler.js";
+export * from "./GitChanges.js";
+export * from "./types.change.js";

package/dist/change/types.change.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { MetaMainData } from "../meta/meta.main.js";
+import { GeneratorEntry } from "../generatorCommon/generator.common.js";
+export interface ChangedHistory {
+    lastCommitHash?: string;
+}
+export declare const changedHistorySchema: z.ZodObject<{
+    lastCommitHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface ChangedTrigger {
+    templateFile: MetaMainData;
+    generators: GeneratorEntry[];
+}
+export interface ChangedResult extends GitChangedContentsResult {
+    triggers: ChangedTrigger[];
+}
+export interface GitChangedResult {
+    path: string;
+    sinceCommit: string;
+    hasChanged: boolean;
+    changedFiles: string[];
+}
+export interface GitChangedContent {
+    absFilePath: string;
+    repoFilePath: string;
+    content: string | null;
+}
+export interface GitChangedContentsResult {
+    path: string;
+    sinceCommit: string;
+    files: GitChangedContent[];
+}

package/dist/change/types.change.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export const changedHistorySchema = z.object({
+    lastCommitHash: z.string().optional(),
+});

package/dist/generator/Generator.d.ts

@@ -0,0 +1,34 @@
+import { MetaFileExtension, MetaFileType } from "../meta/meta.enum.js";
+import { TargetType } from "../meta/meta.common.js";
+import { MetaMainData } from "../meta/meta.main.js";
+import { MetaImport, MetaNames } from "../meta/meta.types.js";
+import { Collector } from "../generatorCommon/Collector.js";
+export interface GeneratorBase {
+    imports: MetaImport[];
+    code: string[];
+}
+export interface GeneratorCode extends GeneratorBase {
+    name: string;
+}
+export interface GeneratorResultFile extends GeneratorBase {
+    type: MetaFileType;
+    ext: MetaFileExtension;
+    inputFilePath: string;
+    targetFilePath: string;
+    importsCode: string[];
+}
+export declare const importsToCode: (imports: MetaImport[]) => string[];
+export declare abstract class Generator {
+    readonly type: MetaFileType;
+    readonly ext: MetaFileExtension;
+    readonly targetType: TargetType;
+    readonly collector: Collector;
+    readonly useAdditionalImports: boolean;
+    constructor(type: MetaFileType, ext: MetaFileExtension, targetType: TargetType, collector: Collector, useAdditionalImports?: boolean);
+    run(interfaceData: MetaMainData[]): GeneratorResultFile[];
+    static write(files: GeneratorResultFile[]): Promise<void>;
+    protected addCode(res: GeneratorResultFile, code: string[]): void;
+    protected addImport(res: GeneratorResultFile, imp: MetaImport): void;
+    protected addImports(res: GeneratorResultFile, imports: MetaImport[]): void;
+    protected abstract runInterface(interfaceData: MetaMainData, names: MetaNames): GeneratorCode | undefined;
+}

package/dist/generator/Generator.js

@@ -0,0 +1,110 @@
+import { basename, dirname } from "node:path";
+import { MetaFileExtension } from "../meta/meta.enum.js";
+import { formatCode, formatJson, TargetType, toFilename, toTargetPath, } from "../meta/meta.common.js";
+import { mkdir, writeFile } from "node:fs/promises";
+import { metaBackendNames, metaBasename, metaFrontendNames, metaNames, } from "../meta/meta.names.js";
+export const importsToCode = (imports) => {
+    const code = [];
+    for (const imp of imports)
+        if (imp.props.length > 0)
+            code.push(`import ${imp.isType ? "type " : ""}{ ${[...imp.props].join(", ")} } from "${imp.path}"`);
+    return code;
+};
+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;
+    }
+    run(interfaceData) {
+        const results = [];
+        for (const data of interfaceData) {
+            let res = results.find((r) => r.inputFilePath === data.inputFilePath);
+            let append = false;
+            if (!res) {
+                append = true;
+                const targetFilename = toFilename({
+                    filename: basename(data.inputFilePath),
+                    type: this.type,
+                    ext: this.ext,
+                    generated: true,
+                });
+                res = {
+                    inputFilePath: data.inputFilePath,
+                    targetFilePath: toTargetPath(this.type, targetFilename, this.targetType),
+                    imports: [],
+                    importsCode: [],
+                    code: [],
+                    ext: this.ext,
+                    type: this.type,
+                };
+            }
+            const extrName = metaBasename(data.templateName);
+            const names = this.targetType === TargetType.backend
+                ? metaBackendNames(extrName)
+                : this.targetType === TargetType.frontend
+                    ? metaFrontendNames(extrName)
+                    : metaNames(extrName);
+            this.collector.add(names.basename, this.targetType, { names });
+            const interfaceRes = this.runInterface(data, names);
+            if (!interfaceRes)
+                continue;
+            this.addCode(res, interfaceRes.code);
+            this.addImports(res, interfaceRes.imports);
+            if (this.useAdditionalImports && data.additionalImports)
+                this.addImports(res, data.additionalImports);
+            if (append)
+                results.push(res);
+        }
+        for (const result of results)
+            result.importsCode = importsToCode(result.imports);
+        return results;
+    }
+    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);
+    }
+    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);
+    }
+}

package/dist/generator/GeneratorAnnotations.d.ts

@@ -0,0 +1,9 @@
+import { MetaMainData } from "../meta/meta.main.js";
+import { MetaNames } from "../meta/meta.types.js";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorAnnotations extends Generator {
+    constructor();
+    protected runInterface(mainData: MetaMainData, names: MetaNames): GeneratorCode | undefined;
+}
+declare const _default: GeneratorAnnotations;
+export default _default;

package/dist/generator/GeneratorAnnotations.js

@@ -0,0 +1,23 @@
+import { Collector } from "../generatorCommon/Collector.js";
+import { TargetType } from "../meta/meta.common.js";
+import { MetaFileType, MetaFileExtension } from "../meta/meta.enum.js";
+import { isMetaNameType, metaBasename } from "../meta/meta.names.js";
+import { Generator } from "./Generator.js";
+export class GeneratorAnnotations extends Generator {
+    constructor() {
+        super(MetaFileType.annotations, MetaFileExtension.ts, TargetType.common, Collector.instance());
+    }
+    runInterface(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 GeneratorAnnotations();

package/dist/generator/GeneratorBackend.d.ts

@@ -0,0 +1,13 @@
+import { MetaMainData, MetaRoutes } from "../meta/meta.main.js";
+import { MetaNames } from "../meta/meta.types.js";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorBackend extends Generator {
+    constructor();
+    protected runInterface(mainData: MetaMainData, names: MetaNames): GeneratorCode | undefined;
+    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,131 @@
+import { Collector } from "../generatorCommon/Collector.js";
+import { lowerFirstLetter, TargetType } from "../meta/meta.common.js";
+import { MetaFileType, MetaFileExtension, isCrudRoute, hasCrudRoute, } from "../meta/meta.enum.js";
+import { Generator } from "./Generator.js";
+export class GeneratorBackend extends Generator {
+    constructor() {
+        super(MetaFileType.backend, MetaFileExtension.ts, TargetType.backend, Collector.instance(), true);
+    }
+    runInterface(mainData, names) {
+        if (Object.keys(mainData.routes).length === 0)
+            return;
+        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"],
+                    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: "@picpad/gen-common/routes",
+                    props: [names.routes],
+                    isType: true,
+                },
+                {
+                    path: "@picpad/gen-common/doc",
+                    props: [names.doc],
+                    isType: true,
+                },
+                {
+                    path: "@mxpicture/gcp-functions-backend/function",
+                    props: ["IBackendFunction"],
+                    isType: false,
+                },
+                {
+                    path: "@picpad/gen-common/routes",
+                    props: [`${names.routes}Name`],
+                    isType: false,
+                },
+                {
+                    path: "@picpad/gen-backend/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() { super("${lowerFirstLetter(names.basename)}"); }`,
+            "}",
+        ];
+    }
+    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}) => {`,
+            `  const store = new ${names.store}();`,
+            "",
+            `  const val = new Validation<${names.doc}>("${lowerFirstLetter(names.basename)}");`,
+            `  val.useShape(${names.shape});`,
+            "",
+            `  const func = new ${names.func}();`,
+            "  func.useApi(api);",
+            `  func.useRoutes(Object.keys(${names.routes}Name));`,
+            "",
+            "  api.useStore(store);",
+            "  api.useValidation(val);",
+            "",
+            "  return func.buildFunction();",
+            "};",
+        ];
+    }
+}
+export default new GeneratorBackend();

package/dist/generator/GeneratorDoc.d.ts

@@ -0,0 +1,9 @@
+import { MetaMainData } from "../meta/meta.main.js";
+import { MetaNames } from "../meta/meta.types.js";
+import { Generator, GeneratorCode } from "./Generator.js";
+export declare class GeneratorDoc extends Generator {
+    constructor();
+    protected runInterface(mainData: MetaMainData, names: MetaNames): GeneratorCode | undefined;
+}
+declare const _default: GeneratorDoc;
+export default _default;