create-gen-app 0.1.6 → 0.2.0

package/template-cache.js

@@ -0,0 +1,260 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateCache = void 0;
+const child_process_1 = require("child_process");
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const appstash_1 = require("appstash");
+const clone_1 = require("./clone");
+const DEFAULT_TOOL = "pgpm";
+/**
+ * Manages template repository caching with TTL support
+ */
+class TemplateCache {
+    config;
+    reposDir;
+    metadataDir;
+    constructor(options) {
+        this.config = this.normalizeConfig(options);
+        if (this.config.enabled) {
+            const dirs = (0, appstash_1.appstash)(this.config.toolName, {
+                ensure: true,
+                baseDir: this.config.baseDir,
+            });
+            this.reposDir = (0, appstash_1.resolve)(dirs, "cache", "repos");
+            this.metadataDir = (0, appstash_1.resolve)(dirs, "cache", "metadata");
+            if (!fs.existsSync(this.reposDir)) {
+                fs.mkdirSync(this.reposDir, { recursive: true });
+            }
+            if (!fs.existsSync(this.metadataDir)) {
+                fs.mkdirSync(this.metadataDir, { recursive: true });
+            }
+        }
+        else {
+            this.reposDir = "";
+            this.metadataDir = "";
+        }
+    }
+    normalizeConfig(options) {
+        if (options === false) {
+            return {
+                enabled: false,
+                toolName: DEFAULT_TOOL,
+            };
+        }
+        const { enabled, toolName, baseDir, ttl, maxAge } = options ?? {};
+        return {
+            enabled: enabled !== false,
+            toolName: toolName ?? DEFAULT_TOOL,
+            baseDir,
+            ttl: ttl ?? maxAge,
+        };
+    }
+    /**
+     * Get cached template if it exists and is not expired
+     */
+    get(templateUrl, branch) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        const key = this.createCacheKey(templateUrl, branch);
+        const cachePath = path.join(this.reposDir, key);
+        const metadataPath = path.join(this.metadataDir, `${key}.json`);
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        if (this.config.ttl && fs.existsSync(metadataPath)) {
+            try {
+                const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
+                if (this.isExpired(metadata)) {
+                    this.clear(templateUrl, branch);
+                    return null;
+                }
+            }
+            catch (error) {
+                // If metadata is corrupted, treat as expired
+                this.clear(templateUrl, branch);
+                return null;
+            }
+        }
+        return cachePath;
+    }
+    /**
+     * Cache a template repository
+     */
+    set(templateUrl, branch) {
+        if (!this.config.enabled) {
+            throw new Error("Cache is disabled");
+        }
+        const key = this.createCacheKey(templateUrl, branch);
+        const cachePath = path.join(this.reposDir, key);
+        const metadataPath = path.join(this.metadataDir, `${key}.json`);
+        // Clone the repository
+        this.cloneInto(templateUrl, cachePath, branch);
+        // Write metadata
+        const metadata = {
+            templateUrl,
+            branch,
+            timestamp: Date.now(),
+            gitUrl: (0, clone_1.normalizeGitUrl)(templateUrl),
+        };
+        fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+        return cachePath;
+    }
+    /**
+     * Clear a specific cached template
+     */
+    clear(templateUrl, branch) {
+        if (!this.config.enabled) {
+            return;
+        }
+        const key = this.createCacheKey(templateUrl, branch);
+        const cachePath = path.join(this.reposDir, key);
+        const metadataPath = path.join(this.metadataDir, `${key}.json`);
+        if (fs.existsSync(cachePath)) {
+            fs.rmSync(cachePath, { recursive: true, force: true });
+        }
+        if (fs.existsSync(metadataPath)) {
+            fs.rmSync(metadataPath, { force: true });
+        }
+    }
+    /**
+     * Clear all cached templates
+     */
+    clearAll() {
+        if (!this.config.enabled) {
+            return;
+        }
+        if (fs.existsSync(this.reposDir)) {
+            fs.rmSync(this.reposDir, { recursive: true, force: true });
+            fs.mkdirSync(this.reposDir, { recursive: true });
+        }
+        if (fs.existsSync(this.metadataDir)) {
+            fs.rmSync(this.metadataDir, { recursive: true, force: true });
+            fs.mkdirSync(this.metadataDir, { recursive: true });
+        }
+    }
+    /**
+     * Check if cache metadata is expired
+     */
+    isExpired(metadata) {
+        if (!this.config.ttl) {
+            return false;
+        }
+        const age = Date.now() - metadata.timestamp;
+        return age > this.config.ttl;
+    }
+    /**
+     * Get cache metadata for a template
+     */
+    getMetadata(templateUrl, branch) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        const key = this.createCacheKey(templateUrl, branch);
+        const metadataPath = path.join(this.metadataDir, `${key}.json`);
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List all cached templates with their metadata
+     */
+    listAll() {
+        if (!this.config.enabled) {
+            return [];
+        }
+        if (!fs.existsSync(this.metadataDir)) {
+            return [];
+        }
+        const results = [];
+        const files = fs.readdirSync(this.metadataDir);
+        for (const file of files) {
+            if (!file.endsWith(".json")) {
+                continue;
+            }
+            const metadataPath = path.join(this.metadataDir, file);
+            try {
+                const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
+                results.push({
+                    ...metadata,
+                    key: path.basename(file, ".json"),
+                    expired: this.isExpired(metadata),
+                });
+            }
+            catch {
+                // Skip corrupted metadata
+            }
+        }
+        return results;
+    }
+    createCacheKey(templateUrl, branch) {
+        const gitUrl = (0, clone_1.normalizeGitUrl)(templateUrl);
+        return crypto
+            .createHash("md5")
+            .update(`${gitUrl}#${branch ?? "default"}`)
+            .digest("hex");
+    }
+    cloneInto(templateUrl, destination, branch) {
+        if (fs.existsSync(destination)) {
+            fs.rmSync(destination, { recursive: true, force: true });
+        }
+        const gitUrl = (0, clone_1.normalizeGitUrl)(templateUrl);
+        const branchArgs = branch ? ` --branch ${branch} --single-branch` : "";
+        const depthArgs = " --depth 1";
+        (0, child_process_1.execSync)(`git clone${branchArgs}${depthArgs} ${gitUrl} ${destination}`, {
+            stdio: "inherit",
+        });
+        const gitDir = path.join(destination, ".git");
+        if (fs.existsSync(gitDir)) {
+            fs.rmSync(gitDir, { recursive: true, force: true });
+        }
+    }
+    isEnabled() {
+        return this.config.enabled;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.TemplateCache = TemplateCache;

package/types.d.ts

@@ -50,6 +50,37 @@ export interface CreateGenOptions {
      * Whether to use TTY for interactive prompts
      */
     noTty?: boolean;
+    /**
+     * Optional caching configuration. Pass `false` to disable caching entirely.
+     */
+    cache?: CacheOptions | false;
+}
+/**
+ * Options that control template caching behavior
+ */
+export interface CacheOptions {
+    /**
+     * Enable or disable caching. Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * Tool name used for appstash (affects ~/.<tool> dirs). Defaults to `pgpm`.
+     */
+    toolName?: string;
+    /**
+     * Optional base directory for appstash. Useful for tests to avoid touching the real home dir.
+     */
+    baseDir?: string;
+    /**
+     * Time-to-live in milliseconds. If set, cached templates older than this will be invalidated.
+     * Defaults to undefined (no expiration).
+     */
+    ttl?: number;
+    /**
+     * Alias for ttl. Maximum age in milliseconds for cached templates.
+     * Defaults to undefined (no expiration).
+     */
+    maxAge?: number;
 }
 /**
  * Result of extracting variables from a template

package/cli.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-export interface CliResult {
-    outputDir: string;
-    template: string;
-}
-export declare function runCli(rawArgv?: string[]): Promise<CliResult | void>;

package/cli.js

@@ -1,239 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCli = runCli;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const inquirerer_1 = require("inquirerer");
-const minimist_1 = __importDefault(require("minimist"));
-const clone_1 = require("./clone");
-const index_1 = require("./index");
-const package_json_1 = __importDefault(require("../package.json"));
-const DEFAULT_REPO = "https://github.com/launchql/pgpm-boilerplates.git";
-const DEFAULT_PATH = ".";
-const DEFAULT_OUTPUT_FALLBACK = "create-gen-app-output";
-const PACKAGE_VERSION = package_json_1.default.version ?? "0.0.0";
-const RESERVED_ARG_KEYS = new Set([
-    "_",
-    "repo",
-    "r",
-    "branch",
-    "b",
-    "path",
-    "p",
-    "template",
-    "t",
-    "output",
-    "o",
-    "force",
-    "f",
-    "help",
-    "h",
-    "version",
-    "v",
-    "no-tty",
-    "n",
-]);
-async function runCli(rawArgv = process.argv.slice(2)) {
-    const args = (0, minimist_1.default)(rawArgv, {
-        alias: {
-            r: "repo",
-            b: "branch",
-            p: "path",
-            t: "template",
-            o: "output",
-            f: "force",
-            h: "help",
-            v: "version",
-            n: "no-tty",
-        },
-        string: ["repo", "branch", "path", "template", "output"],
-        boolean: ["force", "help", "version", "no-tty"],
-        default: {
-            repo: DEFAULT_REPO,
-            path: DEFAULT_PATH,
-        },
-    });
-    if (args.help) {
-        printHelp();
-        return;
-    }
-    if (args.version) {
-        printVersion();
-        return;
-    }
-    if (!args.output && args._[0]) {
-        args.output = args._[0];
-    }
-    let tempDir = null;
-    try {
-        console.log(`Cloning template from ${args.repo}...`);
-        if (args.branch) {
-            console.log(`Using branch ${args.branch}`);
-        }
-        tempDir = await (0, clone_1.cloneRepo)(args.repo, { branch: args.branch });
-        const selectionRoot = path.join(tempDir, args.path);
-        if (!fs.existsSync(selectionRoot) || !fs.statSync(selectionRoot).isDirectory()) {
-            throw new Error(`Template path "${args.path}" does not exist in ${args.repo}`);
-        }
-        const templates = fs
-            .readdirSync(selectionRoot, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
-            .map((entry) => entry.name)
-            .sort();
-        if (templates.length === 0) {
-            throw new Error("No template folders found in repository");
-        }
-        let selectedTemplate = args.template;
-        if (selectedTemplate) {
-            if (!templates.includes(selectedTemplate)) {
-                throw new Error(`Template "${selectedTemplate}" not found in ${args.repo}${args.path === "." ? "" : `/${args.path}`}`);
-            }
-        }
-        else if (templates.length === 1) {
-            selectedTemplate = templates[0];
-            console.log(`Using the only available template: ${selectedTemplate}`);
-        }
-        else {
-            selectedTemplate = await promptForTemplate(templates);
-        }
-        if (!selectedTemplate) {
-            throw new Error("Template selection failed");
-        }
-        const normalizedBasePath = args.path === "." || args.path === "./"
-            ? ""
-            : args.path.replace(/^[./]+/, "").replace(/\/+$/, "");
-        const fromPath = normalizedBasePath
-            ? path.join(normalizedBasePath, selectedTemplate)
-            : selectedTemplate;
-        const outputDir = resolveOutputDir(args.output, selectedTemplate);
-        ensureOutputDir(outputDir, Boolean(args.force));
-        const answerOverrides = extractAnswerOverrides(args);
-        const noTty = Boolean(args["no-tty"] ?? args.noTty);
-        await (0, index_1.createGen)({
-            templateUrl: args.repo,
-            fromBranch: args.branch,
-            fromPath,
-            outputDir,
-            argv: answerOverrides,
-            noTty,
-        });
-        console.log(`\n✨ Done! Project ready at ${outputDir}`);
-        return { outputDir, template: selectedTemplate };
-    }
-    finally {
-        if (tempDir && fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-    }
-}
-function printHelp() {
-    console.log(`
-create-gen-app CLI
-
-Usage:
-  create-gen-app [options] [outputDir]
-  cga [options] [outputDir]
-
-Options:
-  -r, --repo <url>         Git repository to clone (default: ${DEFAULT_REPO})
-  -b, --branch <name>      Branch to use when cloning
-  -p, --path <dir>         Subdirectory that contains templates (default: .)
-  -t, --template <name>    Template folder to use (will prompt if omitted)
-  -o, --output <dir>       Output directory (defaults to ./<template>)
-  -f, --force              Overwrite the output directory if it exists
-  -v, --version            Show CLI version
-  -n, --no-tty             Disable TTY mode for prompts
-  -h, --help               Show this help message
-
-You can also pass variable overrides, e.g.:
-  create-gen-app --template module --PROJECT_NAME my-app
-`);
-}
-function printVersion() {
-    console.log(`create-gen-app v${PACKAGE_VERSION}`);
-}
-async function promptForTemplate(templates) {
-    const prompter = new inquirerer_1.Inquirerer();
-    const question = {
-        type: "list",
-        name: "template",
-        message: "Which template would you like to use?",
-        options: templates,
-        required: true,
-    };
-    try {
-        const answers = (await prompter.prompt({}, [question]));
-        return answers.template;
-    }
-    finally {
-        if (typeof prompter.close === "function") {
-            prompter.close();
-        }
-    }
-}
-function resolveOutputDir(outputArg, template) {
-    const base = outputArg ?? (template ? path.join(process.cwd(), template) : DEFAULT_OUTPUT_FALLBACK);
-    return path.resolve(base);
-}
-function ensureOutputDir(outputDir, force) {
-    if (!fs.existsSync(outputDir)) {
-        return;
-    }
-    if (!force) {
-        throw new Error(`Output directory "${outputDir}" already exists. Use --force to overwrite or choose another path.`);
-    }
-    fs.rmSync(outputDir, { recursive: true, force: true });
-}
-function extractAnswerOverrides(args) {
-    const overrides = {};
-    for (const [key, value] of Object.entries(args)) {
-        if (RESERVED_ARG_KEYS.has(key)) {
-            continue;
-        }
-        overrides[key] = value;
-    }
-    return overrides;
-}
-if (require.main === module) {
-    runCli().catch((error) => {
-        console.error(error instanceof Error ? error.message : error);
-        process.exitCode = 1;
-    });
-}