@mxpicture/gcp-functions-tools 0.1.59

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,144 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { formatJson } 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 "../common/Extractor.js";
+import { Generator } from "../generator/Generator.js";
+import { createGenerators } from "../common/generator.common.js";
+import { directories } from "../common/Directories.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 directories.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,4 @@
+// This file is auto-generated. Do not edit manually.
+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 "../common/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/common/Barrel.d.ts

@@ -0,0 +1,23 @@
+import { TargetType } from "../meta/meta.common.js";
+export interface BarrelResult {
+    dirPath: string;
+    barrelFilePath: string;
+    exportsCode: string[];
+}
+export interface BarrelFileGroup {
+    dirPath: string;
+    barrelFilename: string;
+    filenames: string[];
+}
+export declare class Barrel {
+    readonly targetType: TargetType;
+    static instances: Barrel[];
+    protected filePaths: string[];
+    static instance(targetType: TargetType): Barrel;
+    protected constructor(targetType: TargetType);
+    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,75 @@
+import { basename, dirname, join } from "node:path";
+import { formatCode } from "../meta/meta.common.js";
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { directories } from "./Directories.js";
+export class Barrel {
+    targetType;
+    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) {
+        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 { TargetType } from "../meta/meta.common.js";
+import { MetaNames } from "../meta/meta.types.js";
+export interface CollectorKey {
+    basename: string;
+    targetType: TargetType;
+}
+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: TargetType, data: CollectorData): void;
+    find(basename: string, targetType: TargetType): CollectorItem | null;
+    findGeneric(name: string): CollectorItem[];
+    findFirst(name: string): CollectorItem | null;
+}

package/dist/common/Collector.js

@@ -0,0 +1,37 @@
+import { metaNameProperties } from "../meta/meta.types.js";
+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,25 @@
+import { TargetType } from "../meta/meta.common.js";
+import { MetaFileType } from "../meta/meta.enum.js";
+export interface DirectoriesParams {
+    cwd: string;
+    templatesDir: string;
+    targetDirs: {
+        common: string;
+        frontend: string;
+        backend: string;
+    };
+}
+declare class Directories {
+    protected _params: DirectoriesParams | null;
+    constructor();
+    setup(params: DirectoriesParams): void;
+    get templatesDir(): string;
+    targetDir(targetType: TargetType): string;
+    targetBasePath(targetType: TargetType): string;
+    toTargetPath(type: MetaFileType, filename: string, targetType: TargetType): string;
+    targetPackageJson(targetType: TargetType): string;
+    templatesPathRead(): Promise<string[]>;
+    protected get params(): DirectoriesParams;
+}
+export declare const directories: Directories;
+export {};

package/dist/common/Directories.js

@@ -0,0 +1,52 @@
+import { join, resolve } from "node:path";
+import { isTemplateFile } from "../meta/meta.common.js";
+import { readdir } from "node:fs/promises";
+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),
+            targetDirs: {
+                backend: resolve(params.cwd, params.targetDirs.backend),
+                frontend: resolve(params.cwd, params.targetDirs.frontend),
+                common: resolve(params.cwd, params.targetDirs.common),
+            },
+        };
+    }
+    get templatesDir() {
+        return this.params.templatesDir;
+    }
+    targetDir(targetType) {
+        return `${this.targetBasePath(targetType)}/src`;
+    }
+    targetBasePath(targetType) {
+        return targetType in this.params.targetDirs
+            ? this.params.targetDirs[targetType]
+            : this.params.targetDirs.common;
+    }
+    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));
+    }
+    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;
+}