@mxpicture/gcp-functions-generator 0.2.0

package/dist/common/Evaluate.js

@@ -0,0 +1,120 @@
+import ts from "typescript";
+export class Evaluate {
+    checker;
+    seen;
+    constructor(checker, seen = new Set()) {
+        this.checker = checker;
+        this.seen = seen;
+    }
+    array(expr) {
+        return ts.isArrayLiteralExpression(expr)
+            ? expr.elements.map((e) => new Evaluate(this.checker).run(e))
+            : undefined;
+    }
+    prop(expr) {
+        if (!ts.isPropertyAccessExpression(expr))
+            return;
+        const sym = this.checker.getSymbolAtLocation(expr);
+        if (!sym)
+            return expr.getText();
+        const decl = sym.valueDeclaration ?? sym.declarations?.[0];
+        if (!decl)
+            return expr.getText();
+        if (decl && ts.isEnumMember(decl)) {
+            try {
+                const val = this.checker.getConstantValue(decl);
+                if (val !== undefined)
+                    return val;
+            }
+            catch { }
+        }
+        if (decl && ts.isVariableDeclaration(decl) && decl.initializer)
+            return new Evaluate(this.checker).run(decl.initializer);
+        return expr.getText();
+    }
+    identifier(expr) {
+        if (!ts.isIdentifier(expr))
+            return;
+        const sym = this.checker.getSymbolAtLocation(expr);
+        if (!sym)
+            return expr.text;
+        const decl = sym.valueDeclaration ?? sym.declarations?.[0];
+        if (!decl)
+            return expr.text;
+        // enum member or const variable with initializer
+        if (ts.isEnumMember(decl)) {
+            try {
+                const val = this.checker.getConstantValue(decl);
+                if (val !== undefined)
+                    return val;
+            }
+            catch {
+                // fallthrough
+            }
+        }
+        if ((ts.isVariableDeclaration(decl) && decl.initializer) ||
+            (ts.isPropertyAssignment(decl) && decl.initializer))
+            return new Evaluate(this.checker).run(decl.initializer);
+        return expr.text;
+    }
+    object(expr) {
+        if (!ts.isObjectLiteralExpression(expr))
+            return undefined;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const out = {};
+        for (const prop of expr.properties) {
+            if (ts.isPropertyAssignment(prop)) {
+                const name = this.getNameText(prop.name);
+                if (name)
+                    out[name] = new Evaluate(this.checker).run(prop.initializer);
+                continue;
+            }
+            if (ts.isShorthandPropertyAssignment(prop)) {
+                // shorthand -> same identifier; try to resolve initializer
+                out[prop.name.text] = new Evaluate(this.checker, this.seen).run(prop.name);
+                continue;
+            }
+            if (ts.isSpreadAssignment(prop)) {
+                const spread = new Evaluate(this.checker).run(prop.expression);
+                if (typeof spread === "object")
+                    Object.assign(out, spread);
+                continue;
+            }
+        }
+        return out;
+    }
+    getNameText(name) {
+        if (ts.isIdentifier(name) ||
+            ts.isStringLiteral(name) ||
+            ts.isNumericLiteral(name))
+            return name.getText().replace(/^["']|["']$/g, "");
+        if (!ts.isComputedPropertyName(name))
+            return undefined;
+        const expr = name.expression;
+        if (ts.isStringLiteral(expr) || ts.isNumericLiteral(expr))
+            return expr.text;
+        return expr.getText();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    run(expr) {
+        if (this.seen.has(expr))
+            return undefined;
+        this.seen.add(expr);
+        // Literals
+        if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr))
+            return expr.text;
+        if (ts.isNumericLiteral(expr))
+            return Number(expr.text);
+        if (expr.kind === ts.SyntaxKind.TrueKeyword)
+            return true;
+        if (expr.kind === ts.SyntaxKind.FalseKeyword)
+            return false;
+        if (expr.kind === ts.SyntaxKind.NullKeyword)
+            return null;
+        return (this.array(expr) ??
+            this.prop(expr) ??
+            this.identifier(expr) ??
+            this.object(expr) ??
+            expr.getText());
+    }
+}

package/dist/common/Extractor.d.ts

@@ -0,0 +1,33 @@
+import ts from "typescript";
+import { DocumentData } from "@mxpicture/gcp-functions-common/types";
+import { CrudRouteName, MetaHeadData, MetaHeadDecorator, MetaHeadOptionsBase, MetaPropertyData, MetaPropertyDecorator, MetaPropertyOptionsBase } from "@mxpicture/gcp-functions-common/meta";
+import type { MetaRouteParams, MetaHeadInterfaceOptions, MetaFile } from "@mxpicture/gcp-functions-common/types";
+export type MetaHeadExtract = {
+    [K in keyof MetaHeadOptionsBase]: (property: ts.ClassDeclaration) => MetaHeadData | undefined;
+};
+export type MetaPropertyExtract = {
+    [K in keyof MetaPropertyOptionsBase]: (property: ts.PropertyDeclaration) => MetaPropertyData | undefined;
+};
+export declare const createExtractors: (filePaths: string[]) => Promise<Extractor[]>;
+export declare const extractFiles: (extractors: Extractor[]) => MetaFile[];
+export declare const crudRoutes: (docName: string) => Record<CrudRouteName, MetaRouteParams>;
+export declare class Extractor {
+    readonly filePath: string;
+    readonly checker: ts.TypeChecker;
+    readonly sourceFile: ts.SourceFile;
+    readonly rootDir: string;
+    protected propertyExtr: MetaPropertyExtract;
+    protected mainExtr: MetaHeadExtract;
+    constructor(filePath: string, checker: ts.TypeChecker, sourceFile: ts.SourceFile, rootDir: string);
+    run(): MetaFile;
+    header(main: ts.ClassDeclaration): MetaHeadData | undefined;
+    property(property: ts.PropertyDeclaration): MetaPropertyData | undefined;
+    protected buildPropertyExtr(): MetaPropertyExtract;
+    protected buildMainExtr(): MetaHeadExtract;
+    protected buildMainExtrRoutes(templateName: string, o: MetaHeadInterfaceOptions): Record<string, MetaRouteParams>;
+    protected findDecorator(modifiers: ts.NodeArray<ts.ModifierLike> | undefined, name: string): ts.Decorator | undefined;
+    protected extractType(property: ts.PropertyDeclaration): string;
+    protected extractProperty<K extends MetaPropertyDecorator, T extends MetaPropertyOptionsBase[K] = MetaPropertyOptionsBase[K]>(type: K, modifiers: ts.NodeArray<ts.ModifierLike> | undefined): T | undefined;
+    protected extractMain<K extends MetaHeadDecorator, T extends MetaHeadOptionsBase[K] = MetaHeadOptionsBase[K]>(type: K, modifiers: ts.NodeArray<ts.ModifierLike> | undefined): T | undefined;
+    protected extractAny<T extends DocumentData>(name: string, modifiers: ts.NodeArray<ts.ModifierLike> | undefined): T | undefined;
+}

package/dist/common/Extractor.js

@@ -0,0 +1,201 @@
+import ts from "typescript";
+import { Evaluate } from "./Evaluate.js";
+import { metaRename } from "../meta/meta.names.js";
+import { relative } from "node:path";
+import { VSCodeWorkspace } from "@mxpicture/gcp-functions-code/vscode";
+import { createSourceFiles } from "@mxpicture/gcp-functions-code/common";
+import { MetaFileType, MetaHeadType, metaMainOptionsMap, metaPropertyOptionsMap, } from "@mxpicture/gcp-functions-common/meta";
+export const createExtractors = async (filePaths) => {
+    const rootDir = (await VSCodeWorkspace.loadAsync()).root;
+    return createSourceFiles(filePaths).map((f) => new Extractor(f.filePath, f.checker, f.sourceFile, rootDir));
+};
+export const extractFiles = (extractors) => extractors.map((extractor) => extractor.run());
+export const crudRoutes = (docName) => ({
+    create: {
+        requestType: `WithoutKey<${docName}>`,
+        responseType: `WithKey<${docName}>`,
+    },
+    update: {
+        requestType: `WithKey<Partial<${docName}>>`,
+        responseType: `WithKey<${docName}>`,
+    },
+    delete: { requestType: "DocumentKey", responseType: "{ deleted: true }" },
+    get: { requestType: "DocumentKey", responseType: `WithKey<${docName}>` },
+    query: {
+        requestType: "ApiFilter | undefined | null | never",
+        responseType: `WithKey<${docName}>[]`,
+    },
+    count: {
+        requestType: "ApiFilter | undefined | null | never",
+        responseType: "{ count: number }",
+    },
+    exists: { requestType: "DocumentKey", responseType: "{ exists: boolean }" },
+});
+export class Extractor {
+    filePath;
+    checker;
+    sourceFile;
+    rootDir;
+    propertyExtr;
+    mainExtr;
+    constructor(filePath, checker, sourceFile, rootDir) {
+        this.filePath = filePath;
+        this.checker = checker;
+        this.sourceFile = sourceFile;
+        this.rootDir = rootDir;
+        this.propertyExtr = this.buildPropertyExtr();
+        this.mainExtr = this.buildMainExtr();
+    }
+    run() {
+        const result = {
+            templateFilePath: this.filePath,
+            templateRepoFilePath: relative(this.rootDir, this.filePath),
+            headers: [],
+        };
+        ts.forEachChild(this.sourceFile, (node) => {
+            if (!ts.isClassDeclaration(node))
+                return;
+            const header = this.header(node);
+            if (!header)
+                return;
+            for (const member of node.members) {
+                if (!ts.isPropertyDeclaration(member) || !member.type)
+                    continue;
+                const prop = this.property(member);
+                if (!prop)
+                    continue;
+                header.properties.push(prop);
+            }
+            result.headers.push(header);
+        });
+        return result;
+    }
+    header(main) {
+        for (const opt of Object.values(this.mainExtr)) {
+            const res = opt(main);
+            if (res)
+                return res;
+        }
+        return;
+    }
+    property(property) {
+        for (const opt of Object.values(this.propertyExtr)) {
+            const res = opt(property);
+            if (res)
+                return res;
+        }
+        return;
+    }
+    buildPropertyExtr() {
+        const opts = {};
+        for (const _key of Object.keys(metaPropertyOptionsMap)) {
+            const decoratorType = _key;
+            opts[decoratorType] = (property) => {
+                const o = this.extractProperty(decoratorType, property.modifiers);
+                if (!o)
+                    return;
+                const res = {
+                    ...o,
+                    [decoratorType]: o,
+                    propertyKey: property.name.getText(this.sourceFile),
+                    propertyType: this.extractType(property),
+                    type: metaPropertyOptionsMap[decoratorType],
+                };
+                return res;
+            };
+        }
+        return opts;
+    }
+    buildMainExtr() {
+        const opts = {};
+        for (const _key of Object.keys(metaMainOptionsMap)) {
+            const decoratorType = _key;
+            opts[decoratorType] = (cls) => {
+                const o = this.extractMain(decoratorType, cls.modifiers);
+                if (!o)
+                    return;
+                const templateName = cls.name?.text ?? "<anonymous>";
+                o.type = metaMainOptionsMap[decoratorType];
+                let routes = {};
+                let additionalImports = undefined;
+                let prefix = undefined;
+                if (o.type === MetaHeadType.mainInterface) {
+                    routes = this.buildMainExtrRoutes(templateName, o);
+                    additionalImports = o.additionalImports;
+                    prefix = o.prefix;
+                }
+                return {
+                    ...o,
+                    templateName,
+                    inputFilePath: this.filePath,
+                    repoInputFilePath: relative(this.rootDir, this.filePath),
+                    properties: [],
+                    routes,
+                    additionalImports,
+                    prefix,
+                };
+            };
+        }
+        return opts;
+    }
+    buildMainExtrRoutes(templateName, o) {
+        const routes = {};
+        for (const [routeName, _params] of Object.entries(o.routes)) {
+            if (typeof _params === "object") {
+                const params = _params;
+                routes[routeName] = { ...params };
+                continue;
+            }
+            // crud
+            if (typeof _params === "boolean" && _params) {
+                for (const [routeName, params] of Object.entries(crudRoutes(metaRename(templateName, MetaFileType.doc))))
+                    routes[routeName] = { ...params };
+                continue;
+            }
+        }
+        return routes;
+    }
+    findDecorator(modifiers, name) {
+        return modifiers?.find((m) => {
+            if (!ts.isDecorator(m))
+                return false;
+            const expr = m.expression;
+            // bare identifier: @Track
+            if (ts.isIdentifier(expr) && expr.text === name)
+                return true;
+            // call expression: @Tracked("...")
+            if (ts.isCallExpression(expr) &&
+                ts.isIdentifier(expr.expression) &&
+                expr.expression.text === name)
+                return true;
+            return false;
+        });
+    }
+    extractType(property) {
+        return property.type
+            ? this.checker.typeToString(this.checker.getTypeFromTypeNode(property.type))
+            : "unknown";
+    }
+    extractProperty(type, modifiers) {
+        return this.extractAny(type, modifiers);
+    }
+    extractMain(type, modifiers) {
+        return this.extractAny(type, modifiers);
+    }
+    extractAny(name, modifiers) {
+        const decorator = this.findDecorator(modifiers, name);
+        if (!decorator)
+            return;
+        const expr = decorator.expression;
+        if (!ts.isCallExpression(expr) || expr.arguments.length === 0)
+            return;
+        const first = expr.arguments[0];
+        const e = new Evaluate(this.checker);
+        // If it's already an object literal, evaluate to a plain object
+        if (ts.isObjectLiteralExpression(first))
+            return e.run(first);
+        // If it's an identifier / enum / referenced const, try to resolve it to a value
+        const resolved = e.run(first);
+        return typeof resolved === "object" ? resolved : undefined;
+    }
+}

package/dist/common/GenChangeDetector.d.ts

@@ -0,0 +1,19 @@
+import { MetaFileType } from "@mxpicture/gcp-functions-common/meta";
+import { ChangeDetector, ChangeEventHandler, Changelog, PackageVersion } from "@mxpicture/gcp-functions-code/changelog";
+import { GitChangesCommit } from "@mxpicture/gcp-functions-code/git";
+export interface GenChangeParams {
+    gitSinceCommit: {
+        rootDir: string;
+        sinceCommit: string;
+    } | GitChangesCommit;
+    log?: Changelog;
+    sinceVersion?: PackageVersion;
+}
+export interface GenChangeResult {
+    fileTypes: MetaFileType[];
+    templateNames: string[];
+}
+export declare class GenChangeDetector<T extends GenChangeResult = GenChangeResult> extends ChangeDetector<T> {
+}
+export declare const genChangeEventHandler: ChangeEventHandler<GenChangeResult>;
+export declare const createGenChangeDetector: (p: GenChangeParams) => GenChangeDetector;

package/dist/common/GenChangeDetector.js

@@ -0,0 +1,33 @@
+import { ChangeDetector, ChangeWatchType, Changelog, } from "@mxpicture/gcp-functions-code/changelog";
+import { GitChangesCommit } from "@mxpicture/gcp-functions-code/git";
+import { createGenerators, } from "@mxpicture/gcp-functions-generator/common";
+export class GenChangeDetector extends ChangeDetector {
+}
+const endsWithName = (path, filenameWoExt) => path.endsWith(`/${filenameWoExt}.ts`) ||
+    path.endsWith(`/${filenameWoExt}.js`);
+const findEndsWithName = (paths, gen) => !!paths.find((path) => endsWithName(path, gen.filenameWoExt));
+export const genChangeEventHandler = async (paths, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+watch) => {
+    const gens = await createGenerators();
+    if (gens.length === 0)
+        return null;
+    const result = { fileTypes: [], templateNames: [] };
+    for (const gen of gens)
+        if (findEndsWithName(paths, gen))
+            result.fileTypes.push(gen.gen.type);
+    return result;
+};
+export const createGenChangeDetector = (p) => {
+    const git = p.gitSinceCommit instanceof GitChangesCommit
+        ? p.gitSinceCommit
+        : new GitChangesCommit(p.gitSinceCommit.rootDir, p.gitSinceCommit.sinceCommit);
+    const log = p.log ?? new Changelog(git);
+    const det = new GenChangeDetector(log, git, p.sinceVersion);
+    det.addWatch({
+        handler: genChangeEventHandler,
+        pattern: "packages/generator/src/generator/Generator*",
+        type: ChangeWatchType.changelog,
+    });
+    return det;
+};

package/dist/common/generator.common.d.ts

@@ -0,0 +1,21 @@
+import { Generator, GeneratorResultFile } from "../generator/Generator.js";
+import { DirectoriesParams } from "./Directories.js";
+import { MetaFile } from "@mxpicture/gcp-functions-common/types";
+export declare const generatorDirPath: string;
+export declare const toolsDirPath: string;
+export interface GeneratorFile {
+    filename: string;
+    filePath: string;
+    filenameWoExt: string;
+    fileExt: string;
+}
+export interface GeneratorEntry extends GeneratorFile {
+    gen: Generator;
+}
+export declare const readGeneratorFiles: () => Promise<GeneratorFile[]>;
+export declare const readGeneratorFile: (filename: string) => Promise<GeneratorFile | null>;
+export declare const createGenerator: (file: GeneratorFile) => Promise<GeneratorEntry | null>;
+export declare const createGenerators: () => Promise<GeneratorEntry[]>;
+export declare const runGeneration: (params: DirectoriesParams) => Promise<void>;
+export declare const runFile: (file: MetaFile, gen: Generator) => Promise<GeneratorResultFile>;
+export declare const runFiles: (files: MetaFile[], gen: Generator) => Promise<GeneratorResultFile[]>;

package/dist/common/generator.common.js

@@ -0,0 +1,86 @@
+import { dirname, join, parse, resolve } from "node:path";
+import { Generator } from "../generator/Generator.js";
+import { fileURLToPath } from "node:url";
+import { readdir } from "node:fs/promises";
+import { directories } from "./Directories.js";
+import { createExtractors, extractFiles } from "./Extractor.js";
+import { Barrel } from "./Barrel.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const generatorDirPath = resolve(__dirname, "../generator");
+export const toolsDirPath = resolve(__dirname, "../..");
+const generators = [];
+let generatorFiles = null;
+export const readGeneratorFiles = async () => {
+    if (!generatorFiles) {
+        const filenames = (await readdir(generatorDirPath)).filter((filename) => filename !== "Generator.ts" &&
+            filename !== "Generator.js" &&
+            !filename.endsWith(".d.ts") &&
+            (filename.endsWith(".ts") || filename.endsWith(".js")));
+        generatorFiles = await Promise.all(filenames.map(async (filename) => {
+            const filePath = join(generatorDirPath, filename);
+            const parsed = parse(filename);
+            return {
+                filename,
+                filePath,
+                filenameWoExt: parsed.name,
+                fileExt: parsed.ext,
+            };
+        }));
+    }
+    return generatorFiles;
+};
+export const readGeneratorFile = async (filename) => (await readGeneratorFiles()).find((file) => file.filename === filename) ??
+    null;
+export const createGenerator = async (file) => {
+    let found = generators.find((generator) => generator.filePath === file.filePath);
+    if (found)
+        return found;
+    const gen = (await import(file.filePath)).default;
+    if (!(gen instanceof Generator))
+        return null;
+    found = { ...file, gen };
+    generators.push(found);
+    return found;
+};
+export const createGenerators = async () => {
+    const files = await readGeneratorFiles();
+    const promises = files.map(createGenerator);
+    const entries = await Promise.all(promises);
+    return entries.filter((entry) => !!entry);
+};
+export const runGeneration = async (params) => {
+    const { files, entries } = await prepareRunGeneration(params);
+    console.log("using:");
+    const targetFilesFiles = await Promise.all(entries.map(async (entry) => {
+        const resultFiles = await runFiles(files, entry.gen);
+        await Generator.write(...resultFiles);
+        return resultFiles;
+    }));
+    const targetFiles = [];
+    for (const tarFiles of targetFilesFiles) {
+        targetFiles.push(...tarFiles);
+        for (const tarFile of tarFiles)
+            Barrel.instance(tarFile.targetType).add(tarFile.targetFilePath);
+    }
+    const promises = [];
+    for (const barrel of Barrel.instances) {
+        const barrelFiles = barrel.create();
+        promises.push(barrel.write(barrelFiles));
+        promises.push(barrel.ensurePackageBarrels(barrelFiles));
+    }
+    await Promise.all(promises);
+};
+const prepareRunGeneration = async (params) => {
+    directories.setup(params);
+    const templateFilePaths = await directories.templatesPathRead();
+    const files = extractFiles(await createExtractors(templateFilePaths));
+    const entries = await createGenerators();
+    return { files, entries };
+};
+export const runFile = async (file, gen) => {
+    console.log(`  - ${gen.type} (${gen.ext})`);
+    const resultFile = await gen.run(file);
+    await Generator.write(resultFile);
+    return resultFile;
+};
+export const runFiles = async (files, gen) => Promise.all(files.map(async (file) => gen.run(file)));

package/dist/common/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Barrel.js";
+export * from "./Collector.js";
+export * from "./Directories.js";
+export * from "./Evaluate.js";
+export * from "./Extractor.js";
+export * from "./GenChangeDetector.js";
+export * from "./generator.common.js";

package/dist/common/index.js

@@ -0,0 +1,8 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./Barrel.js";
+export * from "./Collector.js";
+export * from "./Directories.js";
+export * from "./Evaluate.js";
+export * from "./Extractor.js";
+export * from "./GenChangeDetector.js";
+export * from "./generator.common.js";

package/dist/generator/Generator.d.ts

@@ -0,0 +1,41 @@
+import { MetaFile, MetaImport, MetaNames } from "@mxpicture/gcp-functions-common/types";
+import { MetaFileType, MetaFileExtension, MetaTargetType, MetaHeadData } from "@mxpicture/gcp-functions-common/meta";
+import { Collector } from "../common/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;
+    targetType: MetaTargetType;
+    importsCode: string[];
+}
+export declare const importsToCode: (imports: MetaImport[]) => string[];
+export declare const importsToCodeAsync: (imports: MetaImport[]) => Promise<string[]>;
+export declare abstract class Generator {
+    readonly type: MetaFileType;
+    readonly ext: MetaFileExtension;
+    readonly targetType: MetaTargetType;
+    readonly collector: Collector;
+    readonly useAdditionalImports: boolean;
+    constructor(type: MetaFileType, ext: MetaFileExtension, targetType: MetaTargetType, collector: Collector, useAdditionalImports?: boolean);
+    run(file: MetaFile): Promise<GeneratorResultFile>;
+    static write(...files: GeneratorResultFile[]): Promise<void>;
+    resolveImport(targetType: MetaTargetType, 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;
+    protected processHeader(header: MetaHeadData): Promise<(GeneratorCode & {
+        inputFilePath: string;
+    }) | null>;
+    protected abstract runHeader(interfaceData: MetaHeadData, names: MetaNames): Promise<GeneratorCode | null>;
+}