@mxpicture/gcp-functions-tools 0.1.65 → 0.1.67

package/dist/common/Barrel.d.ts

@@ -11,6 +11,7 @@ export interface BarrelFileGroup {
 }
 export declare class Barrel {
     readonly targetType: TargetType;
+    static ignorePackageJson: boolean;
     static instances: Barrel[];
     protected filePaths: string[];
     static instance(targetType: TargetType): Barrel;

package/dist/common/Barrel.js

@@ -4,6 +4,7 @@ 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) {
@@ -39,6 +40,10 @@ export class Barrel {
         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);

package/dist/common/Directories.d.ts

@@ -1,13 +1,16 @@
 import { TargetType } from "../meta/meta.common.js";
 import { MetaFileType } from "../meta/meta.enum.js";
+export interface DirectoriesResolverParams {
+    targetType: TargetType;
+    fileType: MetaFileType;
+}
+export type DirectoriesResolver = (imp: DirectoriesResolverParams, // e.g ${TargetType}/${MetaFileType} --> common/doc,
+current: DirectoriesResolverParams) => string;
 export interface DirectoriesParams {
     cwd: string;
     templatesDir: string;
-    targetDirs: {
-        common: string;
-        frontend: string;
-        backend: string;
-    };
+    targetDir: string;
+    importResolver: DirectoriesResolver;
 }
 declare class Directories {
     protected _params: DirectoriesParams | null;
@@ -19,6 +22,15 @@ declare class Directories {
     toTargetPath(type: MetaFileType, filename: string, targetType: TargetType): string;
     targetPackageJson(targetType: TargetType): string;
     templatesPathRead(): Promise<string[]>;
+    resolveImport(imp: {
+        targetType: TargetType;
+        fileType: MetaFileType;
+    } | string, currentFile: {
+        targetType: TargetType;
+        fileType: MetaFileType;
+    } | string): string;
+    splitResolverPath(path: string): DirectoriesResolverParams;
+    concatResolverPath(params: DirectoriesResolverParams): string;
     protected get params(): DirectoriesParams;
 }
 export declare const directories: Directories;

package/dist/common/Directories.js

@@ -1,5 +1,6 @@
 import { join, resolve } from "node:path";
-import { isTemplateFile } from "../meta/meta.common.js";
+import { guardTargetType, isTemplateFile, } from "../meta/meta.common.js";
+import { guardMetaFileType } from "../meta/meta.enum.js";
 import { readdir } from "node:fs/promises";
 let __instance = null;
 const instance = () => {
@@ -14,11 +15,8 @@ class Directories {
         this._params = {
             cwd: params.cwd,
             templatesDir: resolve(params.cwd, params.templatesDir),
-            targetDirs: {
-                backend: resolve(params.cwd, params.targetDirs.backend),
-                frontend: resolve(params.cwd, params.targetDirs.frontend),
-                common: resolve(params.cwd, params.targetDirs.common),
-            },
+            targetDir: resolve(params.cwd, params.targetDir),
+            importResolver: params.importResolver,
         };
     }
     get templatesDir() {
@@ -28,9 +26,7 @@ class Directories {
         return `${this.targetBasePath(targetType)}/src`;
     }
     targetBasePath(targetType) {
-        return targetType in this.params.targetDirs
-            ? this.params.targetDirs[targetType]
-            : this.params.targetDirs.common;
+        return join(this.params.targetDir, targetType);
     }
     toTargetPath(type, filename, targetType) {
         return join(this.targetDir(targetType), type, filename);
@@ -43,6 +39,27 @@ class Directories {
             .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 = guardTargetType(_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!");

package/dist/generator/Generator.d.ts

@@ -27,6 +27,10 @@ export declare abstract class Generator {
     constructor(type: MetaFileType, ext: MetaFileExtension, targetType: TargetType, collector: Collector, useAdditionalImports?: boolean);
     run(interfaceData: MetaMainData[]): GeneratorResultFile[];
     static write(files: GeneratorResultFile[]): Promise<void>;
+    resolveImport(targetType: TargetType, fileType: MetaFileType): string;
+    importCommon(fileType: MetaFileType): string;
+    importFrontend(fileType: MetaFileType): string;
+    importBackend(fileType: MetaFileType): string;
     protected addCode(res: GeneratorResultFile, code: string[]): void;
     protected addImport(res: GeneratorResultFile, imp: MetaImport): void;
     protected addImports(res: GeneratorResultFile, imports: MetaImport[]): void;

package/dist/generator/Generator.js

@@ -86,6 +86,18 @@ export class Generator {
         }
         await Promise.all(promises);
     }
+    resolveImport(targetType, fileType) {
+        return directories.resolveImport({ targetType, fileType }, { targetType: this.targetType, fileType: this.type });
+    }
+    importCommon(fileType) {
+        return this.resolveImport(TargetType.common, fileType);
+    }
+    importFrontend(fileType) {
+        return this.resolveImport(TargetType.frontend, fileType);
+    }
+    importBackend(fileType) {
+        return this.resolveImport(TargetType.backend, fileType);
+    }
     addCode(res, code) {
         if (res.code.length > 0)
             res.code.push("");

package/dist/generator/GeneratorAnnotations.js

@@ -1,7 +1,6 @@
 import { Collector } from "../common/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() {
@@ -13,10 +12,11 @@ export class GeneratorAnnotations extends Generator {
             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("}");
+        res.code.push(`export const ${names.annotations} = {`);
+        res.code.push(` title: "${mainData.title}",`);
+        res.code.push(` routes: [],`); // todo
+        res.code.push(` properties: ${JSON.stringify(mainData.properties)},`);
+        res.code.push("};");
         return res;
     }
 }

package/dist/generator/GeneratorBackend.js

@@ -46,12 +46,12 @@ export class GeneratorBackend extends Generator {
                     isType: true,
                 },
                 {
-                    path: "@picpad/gen-common/routes",
+                    path: this.importCommon(MetaFileType.routes),
                     props: [names.routes],
                     isType: true,
                 },
                 {
-                    path: "@picpad/gen-common/doc",
+                    path: this.importCommon(MetaFileType.doc),
                     props: [names.doc],
                     isType: true,
                 },
@@ -61,12 +61,12 @@ export class GeneratorBackend extends Generator {
                     isType: false,
                 },
                 {
-                    path: "@picpad/gen-common/routes",
+                    path: this.importCommon(MetaFileType.routes),
                     props: [`${names.routes}Name`],
                     isType: false,
                 },
                 {
-                    path: "@picpad/gen-backend/zod",
+                    path: this.importBackend(MetaFileType.zod),
                     props: [names.shape],
                     isType: false,
                 },

package/dist/generator/GeneratorFrontend.js

@@ -24,7 +24,7 @@ export class GeneratorFrontend extends Generator {
                     isType: false,
                 },
                 {
-                    path: "@picpad/gen-common/routes",
+                    path: this.importCommon(MetaFileType.routes),
                     props: [`${names.routes}Name`],
                     isType: false,
                 },
@@ -39,12 +39,12 @@ export class GeneratorFrontend extends Generator {
                     isType: true,
                 },
                 {
-                    path: "@picpad/gen-common/routes",
+                    path: this.importCommon(MetaFileType.routes),
                     props: [names.routes],
                     isType: true,
                 },
                 {
-                    path: "@picpad/gen-common/doc",
+                    path: this.importCommon(MetaFileType.doc),
                     props: [names.doc],
                     isType: true,
                 },

package/dist/generator/GeneratorRoutes.js

@@ -25,7 +25,7 @@ export class GeneratorRoutes extends Generator {
                     ],
                 },
                 {
-                    path: "@picpad/gen-common/doc",
+                    path: this.importCommon(MetaFileType.doc),
                     isType: true,
                     props: [names.doc],
                 },

package/dist/meta/meta.common.d.ts

@@ -6,6 +6,7 @@ export declare enum TargetType {
     frontend = "frontend",
     backend = "backend"
 }
+export declare const guardTargetType: (type: string | undefined) => TargetType | undefined;
 export interface ExtractFileParts {
     filename: string;
     type: MetaFileType;

package/dist/meta/meta.common.js

@@ -8,6 +8,9 @@ export var TargetType;
     TargetType["frontend"] = "frontend";
     TargetType["backend"] = "backend";
 })(TargetType || (TargetType = {}));
+export const guardTargetType = (type) => type && Object.values(TargetType).filter((t) => t === type)
+    ? type
+    : undefined;
 export const isTemplateFile = (filename) => isTsFile(filename, MetaFileType.template);
 export const isTsFile = (filename, type) => isAnyFile(filename, type, MetaFileExtension.ts);
 export const isAnyFile = (filename, type, ext) => {

package/dist/meta/meta.names.js

@@ -20,6 +20,7 @@ export const metaNames = (basename) => ({
     store: metaRename(basename, "store"),
     shape: lowerFirstLetter(metaRename(basename, "shape")),
     schema: lowerFirstLetter(metaRename(basename, "schema")),
+    annotations: lowerFirstLetter(metaRename(basename, "annotations")),
 });
 export const metaFrontendNames = (basename) => ({
     ...metaNames(basename),

package/dist/meta/meta.types.d.ts

@@ -99,6 +99,7 @@ export type MetaNamesNoTarget = WithMap<{
     store: string;
     shape: string;
     schema: string;
+    annotations: string;
 }>;
 export interface MetaNames extends MetaNamesNoTarget {
     targetType: TargetType;

package/dist/meta/meta.types.js

@@ -22,5 +22,6 @@ const metaNameDummy = {
     store: "",
     shape: "",
     schema: "",
+    annotations: "",
 };
 export const metaNameProperties = Object.keys(metaNameDummy);

package/dist/testTemplates/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/testTemplates/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, MetaMainInterface, MetaNumber, MetaObject, MetaString, MetaUpdateTime, } from "../meta/meta.decorators.js";
+import { MetaPropertyType } from "../meta/meta.enum.js";
+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([
+    MetaMainInterface({
+        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/testTemplates/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/testTemplates/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, MetaMainInterface, 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([
+    MetaMainInterface({
+        title: "Settings",
+        routes: {
+            crud: true,
+        },
+    })
+], SettingsTemplate);
+export { SettingsTemplate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/gcp-functions-tools",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "description": "Tools for google cloud functions",
   "type": "module",
   "author": "MXPicture",
@@ -26,7 +26,8 @@
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo tsconfig.tsbuildinfo node_modules",
     "lint": "eslint \"src/**/*.{ts,tsx}\" --ext .ts,.tsx",
-    "build": "tsc -b ."
+    "build": "tsc -b .",
+    "test": "vitest run"
   },
   "publishConfig": {
     "access": "public"
@@ -41,9 +42,15 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "@types/micromatch": "^4.0.10",
     "@types/node": "^25.2.0",
     "@types/prettier": "^2.7.3",
-    "typescript": "^5.9.3"
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "eslint": "^9.39.2",
+    "execa": "^9.6.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   }
 }