@mxpicture/gcp-functions-generator 0.2.0

package/dist/4testing/index.d.ts

@@ -0,0 +1 @@
+export * from "./utils.js";

package/dist/4testing/index.js

@@ -0,0 +1,2 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./utils.js";

package/dist/4testing/templates/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./template.medication.js";
+export * from "./template.settings.js";

package/dist/4testing/templates/index.js

@@ -0,0 +1,3 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./template.medication.js";
+export * from "./template.settings.js";

package/dist/4testing/templates/template.medication.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Example: Decorator-based Zod schema generation
+ *
+ * Since TypeScript interfaces are compile-time only and don't exist at runtime,
+ * we demonstrate the decorator system using classes that can serve as both
+ * type definitions and runtime metadata carriers.
+ *
+ * This example shows how to:
+ * 1. Use decorators to annotate class properties
+ * 2. Generate Zod schemas from the decorator metadata
+ * 3. Use the generated schemas for validation
+ */
+import type { DocumentAdmin, DocumentKey } from "@mxpicture/gcp-functions-common/types";
+export declare class MedicationPlanTimesTemplate {
+    morning: number;
+    noon: number;
+    evening: number;
+    night: number;
+}
+export declare class MedicationPlanTemplate {
+    lastPickDate?: Date;
+    times: MedicationPlanTimesTemplate;
+}
+export declare class MedicationTemplate implements DocumentKey, DocumentAdmin {
+    id: string;
+    createTime?: Date;
+    updateTime?: Date;
+    ingredient: string;
+    dosageMg: number;
+    tradeNames: string[];
+    size?: number;
+    stock: number;
+    orderMail?: string;
+    plan?: MedicationPlanTemplate;
+}

package/dist/4testing/templates/template.medication.js

@@ -0,0 +1,134 @@
+/**
+ * Example: Decorator-based Zod schema generation
+ *
+ * Since TypeScript interfaces are compile-time only and don't exist at runtime,
+ * we demonstrate the decorator system using classes that can serve as both
+ * type definitions and runtime metadata carriers.
+ *
+ * This example shows how to:
+ * 1. Use decorators to annotate class properties
+ * 2. Generate Zod schemas from the decorator metadata
+ * 3. Use the generated schemas for validation
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { MetaArray, MetaCreateTime, MetaDate, MetaInterface, MetaKey, MetaHeadInterface, MetaNumber, MetaObject, MetaString, MetaUpdateTime, } from "../../meta/meta.decorators.js";
+import { MetaPropertyType } from "@mxpicture/gcp-functions-common/meta";
+let MedicationPlanTimesTemplate = class MedicationPlanTimesTemplate {
+    morning;
+    noon;
+    evening;
+    night;
+};
+__decorate([
+    MetaNumber({ title: "Morning", min: 0, minInclusive: false }),
+    __metadata("design:type", Number)
+], MedicationPlanTimesTemplate.prototype, "morning", void 0);
+__decorate([
+    MetaNumber({ title: "Noon", min: 0, minInclusive: false }),
+    __metadata("design:type", Number)
+], MedicationPlanTimesTemplate.prototype, "noon", void 0);
+__decorate([
+    MetaNumber({ title: "Evening", min: 0, minInclusive: false }),
+    __metadata("design:type", Number)
+], MedicationPlanTimesTemplate.prototype, "evening", void 0);
+__decorate([
+    MetaNumber({ title: "Night", min: 0, minInclusive: false }),
+    __metadata("design:type", Number)
+], MedicationPlanTimesTemplate.prototype, "night", void 0);
+MedicationPlanTimesTemplate = __decorate([
+    MetaInterface({ title: "Medication Plan Times" })
+], MedicationPlanTimesTemplate);
+export { MedicationPlanTimesTemplate };
+let MedicationPlanTemplate = class MedicationPlanTemplate {
+    lastPickDate;
+    times;
+};
+__decorate([
+    MetaDate({ title: "Last Pick Date", optional: true }),
+    __metadata("design:type", Date)
+], MedicationPlanTemplate.prototype, "lastPickDate", void 0);
+__decorate([
+    MetaObject({ title: "Times" }),
+    __metadata("design:type", MedicationPlanTimesTemplate)
+], MedicationPlanTemplate.prototype, "times", void 0);
+MedicationPlanTemplate = __decorate([
+    MetaInterface({ title: "Medication Plan" })
+], MedicationPlanTemplate);
+export { MedicationPlanTemplate };
+let MedicationTemplate = class MedicationTemplate {
+    id;
+    createTime;
+    updateTime;
+    ingredient;
+    dosageMg;
+    tradeNames;
+    size;
+    stock;
+    orderMail;
+    plan;
+};
+__decorate([
+    MetaKey({}),
+    __metadata("design:type", String)
+], MedicationTemplate.prototype, "id", void 0);
+__decorate([
+    MetaCreateTime({ optional: true }),
+    __metadata("design:type", Date)
+], MedicationTemplate.prototype, "createTime", void 0);
+__decorate([
+    MetaUpdateTime({ optional: true }),
+    __metadata("design:type", Date)
+], MedicationTemplate.prototype, "updateTime", void 0);
+__decorate([
+    MetaString({ title: "Ingredient" }),
+    __metadata("design:type", String)
+], MedicationTemplate.prototype, "ingredient", void 0);
+__decorate([
+    MetaNumber({ title: "Dosage mg", min: 0 }),
+    __metadata("design:type", Number)
+], MedicationTemplate.prototype, "dosageMg", void 0);
+__decorate([
+    MetaArray({ title: "Trade Names", itemType: MetaPropertyType.string }),
+    __metadata("design:type", Array)
+], MedicationTemplate.prototype, "tradeNames", void 0);
+__decorate([
+    MetaNumber({ title: "Size", min: 1, optional: true }),
+    __metadata("design:type", Number)
+], MedicationTemplate.prototype, "size", void 0);
+__decorate([
+    MetaNumber({ title: "Stock", min: 0 }),
+    __metadata("design:type", Number)
+], MedicationTemplate.prototype, "stock", void 0);
+__decorate([
+    MetaString({ title: "Order Mail", optional: true }),
+    __metadata("design:type", String)
+], MedicationTemplate.prototype, "orderMail", void 0);
+__decorate([
+    MetaObject({ title: "Plan", optional: true }),
+    __metadata("design:type", MedicationPlanTemplate)
+], MedicationTemplate.prototype, "plan", void 0);
+MedicationTemplate = __decorate([
+    MetaHeadInterface({
+        title: "Medication",
+        routes: {
+            crud: true,
+            testRoute: { requestType: "DocumentKey", responseType: "{test:boolean}" },
+        },
+        additionalImports: [
+            {
+                path: "@mxpicture/gcp-functions-common/types",
+                props: ["DocumentKey"],
+                isType: true,
+            },
+        ],
+    })
+], MedicationTemplate);
+export { MedicationTemplate };

package/dist/4testing/templates/template.settings.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Example: Decorator-based Zod schema generation
+ *
+ * Since TypeScript interfaces are compile-time only and don't exist at runtime,
+ * we demonstrate the decorator system using classes that can serve as both
+ * type definitions and runtime metadata carriers.
+ *
+ * This example shows how to:
+ * 1. Use decorators to annotate class properties
+ * 2. Generate Zod schemas from the decorator metadata
+ * 3. Use the generated schemas for validation
+ */
+import type { DocumentAdmin, DocumentKey } from "@mxpicture/gcp-functions-common/types";
+export declare class SettingsTemplate implements DocumentKey, DocumentAdmin {
+    id: string;
+    createTime?: Date;
+    updateTime?: Date;
+    active: boolean;
+    name: string;
+    type: string;
+    valueNumber?: number;
+    valueString?: string;
+}

package/dist/4testing/templates/template.settings.js

@@ -0,0 +1,73 @@
+/**
+ * Example: Decorator-based Zod schema generation
+ *
+ * Since TypeScript interfaces are compile-time only and don't exist at runtime,
+ * we demonstrate the decorator system using classes that can serve as both
+ * type definitions and runtime metadata carriers.
+ *
+ * This example shows how to:
+ * 1. Use decorators to annotate class properties
+ * 2. Generate Zod schemas from the decorator metadata
+ * 3. Use the generated schemas for validation
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { MetaBoolean, MetaCreateTime, MetaKey, MetaHeadInterface, MetaNumber, MetaString, MetaUpdateTime, } from "../../meta/meta.decorators.js";
+let SettingsTemplate = class SettingsTemplate {
+    id;
+    createTime;
+    updateTime;
+    active;
+    name;
+    type; // todo enum
+    valueNumber;
+    valueString;
+};
+__decorate([
+    MetaKey({}),
+    __metadata("design:type", String)
+], SettingsTemplate.prototype, "id", void 0);
+__decorate([
+    MetaCreateTime({ optional: true }),
+    __metadata("design:type", Date)
+], SettingsTemplate.prototype, "createTime", void 0);
+__decorate([
+    MetaUpdateTime({ optional: true }),
+    __metadata("design:type", Date)
+], SettingsTemplate.prototype, "updateTime", void 0);
+__decorate([
+    MetaBoolean({ title: "Active" }),
+    __metadata("design:type", Boolean)
+], SettingsTemplate.prototype, "active", void 0);
+__decorate([
+    MetaString({ title: "Name" }),
+    __metadata("design:type", String)
+], SettingsTemplate.prototype, "name", void 0);
+__decorate([
+    MetaString({ title: "Type" }),
+    __metadata("design:type", String)
+], SettingsTemplate.prototype, "type", void 0);
+__decorate([
+    MetaNumber({ title: "Number", optional: true }),
+    __metadata("design:type", Number)
+], SettingsTemplate.prototype, "valueNumber", void 0);
+__decorate([
+    MetaString({ title: "String", optional: true }),
+    __metadata("design:type", String)
+], SettingsTemplate.prototype, "valueString", void 0);
+SettingsTemplate = __decorate([
+    MetaHeadInterface({
+        title: "Settings",
+        routes: {
+            crud: true,
+        },
+    })
+], SettingsTemplate);
+export { SettingsTemplate };

package/dist/4testing/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const testingDir: string;
+export declare const wsRoot: string;
+export declare const templatesDir: string;
+export declare const createTestWorkspace: () => Promise<string>;
+export declare const removeTestWorkspace: (p: string | null) => Promise<void>;

package/dist/4testing/utils.js

@@ -0,0 +1,14 @@
+import { rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+export const testingDir = __dirname;
+export const wsRoot = resolve(testingDir, "../..");
+export const templatesDir = resolve(testingDir, "./templates");
+export const createTestWorkspace = async () => join(testingDir, `generator-test-${Date.now()}`);
+export const removeTestWorkspace = async (p) => {
+    if (!p)
+        return;
+    try {
+        return rm(p, { recursive: true });
+    }
+    catch { }
+};

package/dist/common/Barrel.d.ts

@@ -0,0 +1,24 @@
+import { MetaTargetType } from "@mxpicture/gcp-functions-common/meta";
+export interface BarrelResult {
+    dirPath: string;
+    barrelFilePath: string;
+    exportsCode: string[];
+}
+export interface BarrelFileGroup {
+    dirPath: string;
+    barrelFilename: string;
+    filenames: string[];
+}
+export declare class Barrel {
+    readonly targetType: MetaTargetType;
+    static ignorePackageJson: boolean;
+    static instances: Barrel[];
+    protected filePaths: string[];
+    static instance(targetType: MetaTargetType): Barrel;
+    protected constructor(targetType: MetaTargetType);
+    add(...filePaths: string[]): void;
+    create(): BarrelResult[];
+    write(results: BarrelResult[]): Promise<void>;
+    ensurePackageBarrels(results: BarrelResult[]): Promise<void>;
+    protected groupPaths(filePaths: string[]): BarrelFileGroup[];
+}

package/dist/common/Barrel.js

@@ -0,0 +1,80 @@
+import { basename, dirname, join } from "node:path";
+import { formatCode } from "@mxpicture/gcp-functions-code/common";
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { directories } from "./Directories.js";
+export class Barrel {
+    targetType;
+    static ignorePackageJson = false;
+    static instances = [];
+    filePaths = [];
+    static instance(targetType) {
+        let found = this.instances.find((barrel) => barrel.targetType === targetType);
+        if (!found) {
+            found = new Barrel(targetType);
+            this.instances.push(found);
+        }
+        return found;
+    }
+    constructor(targetType) {
+        this.targetType = targetType;
+    }
+    add(...filePaths) {
+        this.filePaths.push(...filePaths);
+    }
+    create() {
+        return this.groupPaths(this.filePaths).map((group) => ({
+            dirPath: group.dirPath,
+            barrelFilePath: join(group.dirPath, group.barrelFilename),
+            exportsCode: group.filenames.map((fielname) => `export * from "./${fielname}";`),
+        }));
+    }
+    async write(results) {
+        const promises = [];
+        for (const result of results) {
+            promises.push((async () => {
+                const code = await formatCode(result.exportsCode.join("\n"));
+                await mkdir(result.dirPath, { recursive: true });
+                return writeFile(result.barrelFilePath, code);
+            })());
+        }
+        await Promise.all(promises);
+    }
+    async ensurePackageBarrels(results) {
+        if (Barrel.ignorePackageJson) {
+            console.log("ensurePackageBarrels ignored");
+            return;
+        }
+        const filePath = directories.targetPackageJson(this.targetType);
+        const raw = await readFile(filePath, "utf8");
+        const pkg = JSON.parse(raw);
+        for (const result of results) {
+            const parts = result.barrelFilePath.split("/src/");
+            if (parts.length < 2)
+                continue; // todo logging?
+            const indexPath = `./src/${parts[parts.length - 1]}`;
+            const expPath = dirname(`./${parts[parts.length - 1]}`);
+            if (!pkg.exports)
+                pkg.exports = {};
+            pkg.exports[expPath] = indexPath;
+        }
+        await writeFile(filePath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    }
+    groupPaths(filePaths) {
+        const groups = [];
+        for (const filePath of filePaths) {
+            const dirPath = dirname(filePath);
+            const filename = basename(filePath);
+            let group = groups.find((g) => g.dirPath === dirPath);
+            if (!group) {
+                group = {
+                    dirPath,
+                    filenames: [],
+                    barrelFilename: "index.ts",
+                };
+                groups.push(group);
+            }
+            group.filenames.push(filename.replace(/\.ts$/, ".js"));
+        }
+        return groups;
+    }
+}

package/dist/common/Collector.d.ts

@@ -0,0 +1,22 @@
+import { MetaTargetType } from "@mxpicture/gcp-functions-common/meta";
+import { MetaNames } from "@mxpicture/gcp-functions-common/types";
+export interface CollectorKey {
+    basename: string;
+    targetType: MetaTargetType;
+}
+export interface CollectorData {
+    names: MetaNames;
+}
+export interface CollectorItem {
+    key: CollectorKey;
+    data: CollectorData;
+}
+export declare class Collector {
+    protected items: CollectorItem[];
+    static instance(): Collector;
+    constructor();
+    add(basename: string, targetType: MetaTargetType, data: CollectorData): void;
+    find(basename: string, targetType: MetaTargetType): CollectorItem | null;
+    findGeneric(name: string): CollectorItem[];
+    findFirst(name: string): CollectorItem | null;
+}

package/dist/common/Collector.js

@@ -0,0 +1,37 @@
+import { metaNameProperties, } from "@mxpicture/gcp-functions-common/types";
+let __instance = null;
+export class Collector {
+    items = [];
+    static instance() {
+        if (!__instance)
+            __instance = new Collector();
+        return __instance;
+    }
+    constructor() { }
+    add(basename, targetType, data) {
+        if (this.find(basename, targetType))
+            return;
+        this.items.push({ key: { basename, targetType }, data: { ...data } });
+    }
+    find(basename, targetType) {
+        return (this.items.find((item) => item.key.basename === basename && item.key.targetType === targetType) ?? null);
+    }
+    findGeneric(name) {
+        const results = [];
+        for (const item of this.items) {
+            if (item.key.basename === name)
+                results.push(item);
+            for (const prop of metaNameProperties) {
+                if (item.data.names[prop] === name) {
+                    results.push(item);
+                    break;
+                }
+            }
+        }
+        return results;
+    }
+    findFirst(name) {
+        const results = this.findGeneric(name);
+        return results.length > 0 ? results[0] : null;
+    }
+}

package/dist/common/Directories.d.ts

@@ -0,0 +1,36 @@
+import { MetaFileType, MetaTargetType } from "@mxpicture/gcp-functions-common/meta";
+export interface DirectoriesResolverParams {
+    targetType: MetaTargetType;
+    fileType: MetaFileType;
+}
+export type DirectoriesResolver = (imp: DirectoriesResolverParams, // e.g ${TargetType}/${MetaFileType} --> common/doc,
+current: DirectoriesResolverParams) => string;
+export interface DirectoriesParams {
+    cwd: string;
+    templatesDir: string;
+    targetDir: string;
+    importResolver: DirectoriesResolver;
+}
+declare class Directories {
+    protected _params: DirectoriesParams | null;
+    constructor();
+    setup(params: DirectoriesParams): void;
+    get templatesDir(): string;
+    targetDir(targetType: MetaTargetType): string;
+    targetBasePath(targetType: MetaTargetType): string;
+    toTargetPath(type: MetaFileType, filename: string, targetType: MetaTargetType): string;
+    targetPackageJson(targetType: MetaTargetType): string;
+    templatesPathRead(): Promise<string[]>;
+    resolveImport(imp: {
+        targetType: MetaTargetType;
+        fileType: MetaFileType;
+    } | string, currentFile: {
+        targetType: MetaTargetType;
+        fileType: MetaFileType;
+    } | string): string;
+    splitResolverPath(path: string): DirectoriesResolverParams;
+    concatResolverPath(params: DirectoriesResolverParams): string;
+    protected get params(): DirectoriesParams;
+}
+export declare const directories: Directories;
+export {};

package/dist/common/Directories.js

@@ -0,0 +1,69 @@
+import { join, resolve } from "node:path";
+import { isTemplateFile } from "@mxpicture/gcp-functions-code/common";
+import { readdir } from "node:fs/promises";
+import { guardMetaFileType, guardMetaTargetType, } from "@mxpicture/gcp-functions-common/meta";
+let __instance = null;
+const instance = () => {
+    if (!__instance)
+        __instance = new Directories();
+    return __instance;
+};
+class Directories {
+    _params = null;
+    constructor() { }
+    setup(params) {
+        this._params = {
+            cwd: params.cwd,
+            templatesDir: resolve(params.cwd, params.templatesDir),
+            targetDir: resolve(params.cwd, params.targetDir),
+            importResolver: params.importResolver,
+        };
+    }
+    get templatesDir() {
+        return this.params.templatesDir;
+    }
+    targetDir(targetType) {
+        return `${this.targetBasePath(targetType)}/src`;
+    }
+    targetBasePath(targetType) {
+        return join(this.params.targetDir, targetType);
+    }
+    toTargetPath(type, filename, targetType) {
+        return join(this.targetDir(targetType), type, filename);
+    }
+    targetPackageJson(targetType) {
+        return `${this.targetBasePath(targetType)}/package.json`;
+    }
+    async templatesPathRead() {
+        return (await readdir(this.templatesDir))
+            .filter(isTemplateFile)
+            .map((name) => join(this.templatesDir, name));
+    }
+    resolveImport(imp, currentFile) {
+        return this.params.importResolver(typeof imp === "string" ? this.splitResolverPath(imp) : imp, typeof currentFile === "string"
+            ? this.splitResolverPath(currentFile)
+            : currentFile);
+    }
+    splitResolverPath(path) {
+        const parts = path.split("/");
+        if (parts.length !== 2)
+            throw new Error(`${path} does not fit the pattern {TargetType}/{MetaFileType}`);
+        const [_targetType, _fileType] = parts;
+        const fileType = guardMetaFileType(_fileType);
+        if (!fileType)
+            throw new Error(`${path}: fileType ${_fileType} invalid`);
+        const targetType = guardMetaTargetType(_targetType);
+        if (!targetType)
+            throw new Error(`${path}: targetType ${_targetType} invalid`);
+        return { targetType, fileType };
+    }
+    concatResolverPath(params) {
+        return `${params.targetType}/${params.fileType}`;
+    }
+    get params() {
+        if (!this._params)
+            throw new Error("Directories: setup needed!");
+        return this._params;
+    }
+}
+export const directories = instance();

package/dist/common/Evaluate.d.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+export declare class Evaluate {
+    protected checker: ts.TypeChecker;
+    protected seen: Set<ts.Node>;
+    constructor(checker: ts.TypeChecker, seen?: Set<ts.Node>);
+    protected array(expr: ts.Expression): any[] | undefined;
+    protected prop(expr: ts.Expression): any;
+    protected identifier(expr: ts.Expression): any;
+    protected object(expr: ts.Expression): Record<string, any> | undefined;
+    protected getNameText(name: ts.PropertyName): string | undefined;
+    run(expr: ts.Expression): any;
+}