@reliverse/dler 1.7.120 → 1.7.121

package/bin/app/pack/cmd.js

@@ -1,516 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { createJiti } from "jiti";
-import stripJsonComments from "strip-json-comments";
-import { isBinaryExt } from "../utils/binary.js";
-const WHITELABEL_DEFAULT = "DLER";
-const TEMPLATE_VAR = (name, whitelabel) => `${whitelabel}_TPL_${name.toUpperCase()}`;
-const TPLS_DIR = "packed";
-const BINARIES_DIR = "binaries";
-export const escapeTemplateString = (str) => str.replace(/`/g, "\\`").replace(/\\\${/g, "\\u0024{").replace(/\$\{/g, "\\${").replace(/\\\{\{/g, "{{").replace(/\\\}\}/g, "}}").replace(/\r?\n/g, "\\n");
-export const unescapeTemplateString = (str) => str.replace(/\\n/g, "\n").replace(/\\u0024\{/g, "\\${").replace(/\\\\`/g, "`").replace(/\\\\/g, "\\");
-export const hashFile = async (file) => {
-  const buf = await fs.readFile(file);
-  return createHash("sha1").update(buf).digest("hex").slice(0, 10);
-};
-export const getFileMetadata = async (file) => {
-  try {
-    const [stats, hash] = await Promise.all([fs.stat(file), hashFile(file)]);
-    return {
-      updatedAt: stats.mtime.toISOString(),
-      updatedHash: hash
-    };
-  } catch (err) {
-    relinka("warn", `Failed to get metadata for ${file}: ${err.message}`);
-    return {
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedHash: ""
-    };
-  }
-};
-export const walkDir = async (dir) => {
-  let res = [];
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      res = res.concat(await walkDir(full));
-    } else {
-      res.push(full);
-    }
-  }
-  return res;
-};
-export const readFileForTemplate = async (absPath, relPath, binariesOutDir) => {
-  const metadata = await getFileMetadata(absPath);
-  try {
-    if (await isBinaryExt(absPath)) {
-      const hash = metadata.updatedHash;
-      const ext2 = path.extname(absPath);
-      const target = path.join(binariesOutDir, `${hash}${ext2}`);
-      try {
-        await fs.mkdir(binariesOutDir, { recursive: true });
-        await fs.copyFile(absPath, target).catch(async (err) => {
-          if (err.code !== "EEXIST") throw err;
-        });
-      } catch (err) {
-        relinka("error", `Failed copying binary ${relPath}: ${err.message}`);
-        return {
-          content: "",
-          type: "binary",
-          hasError: true,
-          error: err.message,
-          binaryHash: hash,
-          metadata
-        };
-      }
-      return {
-        content: "",
-        type: "binary",
-        binaryHash: hash,
-        metadata
-      };
-    }
-    const raw = await fs.readFile(absPath, "utf8");
-    const ext = path.extname(absPath).toLowerCase();
-    if (ext === ".json") {
-      const comments = {};
-      const lines = raw.split(/\r?\n/);
-      lines.forEach((line, idx) => {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("//") || trimmed.startsWith("/*")) comments[idx + 1] = line;
-      });
-      try {
-        const parsed = JSON.parse(stripJsonComments(raw));
-        return {
-          content: parsed,
-          type: "json",
-          jsonComments: Object.keys(comments).length ? comments : void 0,
-          metadata
-        };
-      } catch (err) {
-        relinka("warn", `Failed to parse JSON file ${relPath}: ${err.message}`);
-        return {
-          content: {},
-          type: "json",
-          hasError: true,
-          error: err.message,
-          jsonComments: Object.keys(comments).length ? comments : void 0,
-          metadata
-        };
-      }
-    }
-    return {
-      content: raw,
-      type: "text",
-      metadata
-    };
-  } catch (err) {
-    relinka("warn", `Failed to read file ${relPath}: ${err.message}`);
-    return {
-      content: "",
-      type: "text",
-      hasError: true,
-      error: err.message,
-      metadata
-    };
-  }
-};
-const findTemplatesObject = (mod) => {
-  if (mod.DLER_TEMPLATES && typeof mod.DLER_TEMPLATES === "object") {
-    return mod.DLER_TEMPLATES;
-  }
-  if (mod.default && typeof mod.default === "object") {
-    return mod.default;
-  }
-  for (const v of Object.values(mod)) {
-    if (v && typeof v === "object" && Object.values(v).every((t) => t && typeof t === "object" && "config" in t)) {
-      return v;
-    }
-  }
-  return {};
-};
-const restoreFile = async (outRoot, relPath, meta, binsDir, force = false) => {
-  const dest = path.join(outRoot, relPath);
-  await fs.mkdir(path.dirname(dest), { recursive: true });
-  try {
-    if (!force) {
-      await fs.access(dest);
-      relinka("verbose", `Skipping existing file (use --force to overwrite): ${relPath}`);
-      return;
-    }
-  } catch {
-  }
-  if (meta.type === "binary") {
-    const ext = path.extname(relPath);
-    const src = path.join(binsDir, `${meta.binaryHash}${ext}`);
-    try {
-      await fs.copyFile(src, dest);
-    } catch (err) {
-      relinka("error", `Missing binary ${src} for ${relPath}: ${err.message}`);
-    }
-  } else if (meta.type === "json") {
-    const jsonStr = JSON.stringify(meta.content, null, 2);
-    await fs.writeFile(dest, jsonStr, "utf8");
-  } else {
-    await fs.writeFile(dest, meta.content, "utf8");
-  }
-  if (meta.metadata?.updatedAt) {
-    const ts = new Date(meta.metadata.updatedAt);
-    await fs.utimes(dest, ts, ts);
-  }
-};
-const unpackTemplates = async (aggregatorPath, outDir, force = false) => {
-  const jiti = createJiti(process.cwd());
-  let mod;
-  try {
-    mod = await jiti.import(aggregatorPath);
-  } catch (err) {
-    throw new Error(`Failed to import aggregator file: ${err.message}`);
-  }
-  const templatesObj = findTemplatesObject(mod);
-  if (!Object.keys(templatesObj).length) {
-    throw new Error("No templates found in aggregator file.");
-  }
-  const binsDir = path.join(path.dirname(aggregatorPath), TPLS_DIR, BINARIES_DIR);
-  let unpackedFiles = 0;
-  for (const [tplName, tpl] of Object.entries(templatesObj)) {
-    relinka("info", `Unpacking template: ${tplName}`);
-    for (const [relPath, meta] of Object.entries(tpl.config.files)) {
-      try {
-        await restoreFile(outDir, relPath, meta, binsDir, force);
-        unpackedFiles++;
-      } catch (err) {
-        relinka("error", `Failed restoring ${relPath}: ${err.message}`);
-      }
-    }
-  }
-  relinka("success", `Unpacked ${unpackedFiles} files into ${outDir}`);
-};
-const writeTypesFile = async (outRoot, outputName) => {
-  const typesFile = path.join(outRoot, `${outputName}-types.ts`);
-  const code = `// Auto-generated type declarations for templates.
-export interface FileMetadata { updatedAt?: string; updatedHash?: string; }
-export interface TemplatesFileContent { content: string | Record<string, unknown>; type: 'text' | 'json' | 'binary'; hasError?: boolean; error?: string; jsonComments?: Record<number, string>; binaryHash?: string; metadata?: FileMetadata; }
-export interface Template { name: string; description: string; config: { files: Record<string, TemplatesFileContent> }; updatedAt?: string; }
-`;
-  await fs.writeFile(typesFile, code, "utf8");
-};
-export default defineCommand({
-  meta: {
-    name: "pack",
-    version: "1.2.0",
-    description: "Pack templates into TS modules or --unpack them back to files"
-  },
-  args: defineArgs({
-    input: {
-      type: "positional",
-      required: true,
-      description: "Input directory (pack) or aggregator file (unpack)"
-    },
-    output: {
-      type: "string",
-      default: "my-templates",
-      description: "Output dir"
-    },
-    whitelabel: {
-      type: "string",
-      default: WHITELABEL_DEFAULT,
-      description: "Rename DLER"
-    },
-    cdn: {
-      type: "string",
-      description: "Remote CDN for binary assets upload (not yet implemented)"
-    },
-    force: {
-      type: "boolean",
-      default: false,
-      description: "Force overwrite existing files"
-    },
-    update: {
-      type: "boolean",
-      default: true,
-      description: "Update existing templates and add new ones (pack mode only)"
-    },
-    files: {
-      type: "string",
-      description: "Comma-separated list of specific files to update"
-    },
-    lastUpdate: {
-      type: "string",
-      description: "Override lastUpdate timestamp (pack mode only)"
-    },
-    unpack: {
-      type: "boolean",
-      default: false,
-      description: "Unpack templates from an aggregator file"
-    }
-  }),
-  async run({ args }) {
-    if (args.cdn) throw new Error("Remote CDN support is not implemented yet.");
-    if (args.unpack) {
-      const aggrPath = path.resolve(args.input);
-      const outDir2 = path.resolve(args.output);
-      try {
-        const stat = await fs.stat(aggrPath);
-        if (!stat.isFile() || !aggrPath.endsWith(".ts")) {
-          throw new Error("Input for --unpack must be a TypeScript aggregator file (*.ts)");
-        }
-      } catch (err) {
-        relinka("error", err.message);
-        process.exit(1);
-      }
-      relinka("info", `Unpacking templates from ${aggrPath} to ${outDir2}`);
-      try {
-        await unpackTemplates(aggrPath, outDir2, args.force);
-      } catch (err) {
-        relinka("error", err.message);
-        process.exit(1);
-      }
-      return;
-    }
-    const dirToProcess = path.resolve(args.input);
-    const outDir = path.resolve(args.output);
-    const outDirName = path.basename(outDir);
-    const typesFile = `${outDirName}-types.ts`;
-    const modFile = `${outDirName}-mod.ts`;
-    relinka("info", `Packing templates from ${dirToProcess} to ${outDir}`);
-    const filesToUpdate = args.files ? new Set(args.files.split(",").map((f) => f.trim())) : null;
-    let existingTemplates = {};
-    try {
-      const files = await fs.readdir(outDir);
-      if (files.length > 0) {
-        if (!args.force && !args.update) {
-          relinka("error", `Error: Output directory '${outDir}' already exists and is not empty.`);
-          relinka(
-            "error",
-            "Use --force to overwrite all files or --update to update existing templates."
-          );
-          process.exit(1);
-        }
-        if (args.update) {
-          try {
-            const modPath = path.join(outDir, modFile);
-            const jiti = createJiti(process.cwd());
-            const mod2 = await jiti.import(modPath);
-            existingTemplates = mod2?.DLER_TEMPLATES || mod2?.default || {};
-          } catch (loadError) {
-            relinka(
-              "warn",
-              `Warning: Could not load existing templates from ${modFile}. Will create new ones.`
-            );
-            relinka("verbose", `Error details: ${loadError.message}`);
-          }
-        }
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-    }
-    await fs.mkdir(path.join(outDir, TPLS_DIR), { recursive: true });
-    const templateDirs = (await fs.readdir(dirToProcess, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
-    try {
-      await fs.access(path.join(outDir, typesFile));
-    } catch {
-      await writeTypesFile(outDir, outDirName);
-    }
-    const aggregatedImports = [];
-    const aggregatedEntries = [];
-    const mapEntries = [];
-    for (const tplName of templateDirs) {
-      relinka("info", `Processing template: ${tplName}`);
-      const absTplDir = path.join(dirToProcess, tplName);
-      const allFiles = await walkDir(absTplDir);
-      const filesRecord = {};
-      const existingTemplate = args.update ? existingTemplates[tplName] : null;
-      const existingFiles = existingTemplate?.config?.files || {};
-      for (const absFile of allFiles) {
-        const rel = path.relative(dirToProcess, absFile).replace(/\\/g, "/");
-        if (filesToUpdate && !filesToUpdate.has(rel)) {
-          if (existingFiles[rel]) {
-            filesRecord[rel] = existingFiles[rel];
-          }
-          continue;
-        }
-        const fileMetadata = await getFileMetadata(absFile);
-        const existingFile = existingFiles[rel];
-        const existingMetadata = existingFile?.metadata;
-        if (existingMetadata?.updatedHash && fileMetadata.updatedHash && (existingMetadata.updatedHash === fileMetadata.updatedHash || fileMetadata.updatedAt && existingMetadata.updatedAt && fileMetadata.updatedAt <= existingMetadata.updatedAt)) {
-          filesRecord[rel] = existingFile;
-          continue;
-        }
-        const meta = await readFileForTemplate(
-          absFile,
-          rel,
-          path.join(outDir, TPLS_DIR, BINARIES_DIR)
-        );
-        if (meta.type === "binary") {
-          const hash = await hashFile(absFile);
-          const ext = path.extname(absFile);
-          const binariesDir = path.join(outDir, TPLS_DIR, BINARIES_DIR);
-          const target = path.join(binariesDir, `${hash}${ext}`);
-          await fs.mkdir(binariesDir, { recursive: true });
-          try {
-            await fs.access(target);
-          } catch {
-            await fs.copyFile(absFile, target);
-          }
-          filesRecord[rel] = {
-            type: "binary",
-            content: "",
-            binaryHash: hash,
-            metadata: fileMetadata
-          };
-          continue;
-        }
-        if (meta.type === "json") {
-        }
-        filesRecord[rel] = {
-          ...meta,
-          metadata: fileMetadata
-        };
-      }
-      const varName = TEMPLATE_VAR(tplName, args.whitelabel);
-      const code = [];
-      const hasPackageJson = Object.keys(filesRecord).some((rel) => rel.endsWith("package.json")) || Object.values(filesRecord).some(
-        (f) => f.type === "json" && f.content && typeof f.content === "object" && "name" in f.content
-      );
-      const tsconfigPathRe = /(?:^|\/)tsconfig(?:\.[^/]+)?\.json$/;
-      const hasTSConfig = Object.keys(filesRecord).some((rel) => tsconfigPathRe.test(rel)) || Object.values(filesRecord).some(
-        (f) => f.type === "json" && f.content && typeof f.content === "object" && "compilerOptions" in f.content
-      );
-      if (hasPackageJson || hasTSConfig) {
-        const t = [];
-        if (hasPackageJson) t.push("PackageJson");
-        if (hasTSConfig) t.push("TSConfig");
-        code.push(`import type { ${t.join(", ")} } from "pkg-types";`);
-        code.push("", `import type { Template } from "../${typesFile}";`);
-      } else {
-        code.push(`import type { Template } from "../${typesFile}";`);
-      }
-      code.push("");
-      code.push(`export const ${varName}: Template = {`);
-      code.push(`  name: "${tplName}",`);
-      code.push(`  description: "Template generated from ${allFiles.length} files",`);
-      code.push(`  updatedAt: "${(/* @__PURE__ */ new Date()).toISOString()}",`);
-      code.push("  config: {");
-      code.push("    files: {");
-      const fileEntries = Object.entries(filesRecord);
-      fileEntries.forEach(([rel, meta], index) => {
-        const isLast = index === fileEntries.length - 1;
-        code.push(`      "${rel}": {`);
-        if (meta.jsonComments)
-          code.push(`        jsonComments: ${JSON.stringify(meta.jsonComments, null, 2)},`);
-        if (meta.metadata) {
-          const metadataStr = JSON.stringify(meta.metadata, null, 2).replace(/^/gm, "        ").replace(/^ {7} {/m, " {").replace(/^ {8}}/m, "        }").replace(/"([a-zA-Z0-9_]+)":/g, "$1:").replace(/\n(\s*)}/, ",\n$1}").replace(/}$/m, "},");
-          code.push(`        metadata:${metadataStr}`);
-        }
-        if (meta.type === "binary") {
-          code.push(`        content: "",`);
-          code.push(`        type: "binary",`);
-          code.push(`        binaryHash: "${meta.binaryHash}",`);
-        } else if (meta.type === "text") {
-          code.push(`        content: \`${escapeTemplateString(meta.content)}\`,`);
-          code.push('        type: "text",');
-        } else {
-          let clone;
-          let sat = "";
-          try {
-            clone = JSON.parse(JSON.stringify(meta.content));
-            if (rel.endsWith("package.json")) {
-              sat = " satisfies PackageJson";
-            } else if (tsconfigPathRe.test(rel)) {
-              sat = " satisfies TSConfig";
-            }
-          } catch (error) {
-            clone = {};
-            relinka("error", `Failed to process JSON content for ${rel}: ${error}`);
-          }
-          const jsonStr = JSON.stringify(clone, null, 2).split("\n").map((line, i) => {
-            if (i === 0) return line;
-            return `        ${line.replace(/"([a-zA-Z0-9_]+)":/g, "$1:")}`;
-          }).join("\n").replace(/\n(\s*)}/, ",\n$1}").replace(/,\s*,/g, ",");
-          code.push(`        content: ${jsonStr}${sat},`);
-          code.push('        type: "json",');
-        }
-        if (meta.hasError) {
-          code.push("        hasError: true,");
-          if (meta.error) {
-            code.push(`        error: "${escapeTemplateString(meta.error)}",`);
-          }
-        }
-        code.push(`      }${isLast ? "" : ","}`);
-      });
-      code.push("    },");
-      code.push("  },");
-      code.push("};");
-      code.push("");
-      const templatePath = path.join(outDir, TPLS_DIR, `${tplName}.ts`);
-      if (args.update && existingTemplates[tplName]) {
-        try {
-          const existingContent = await fs.readFile(templatePath, "utf8");
-          const newContent = code.join("\n");
-          if (existingContent !== newContent) {
-            if (filesToUpdate) {
-              relinka("verbose", `Updating specific files in template: ${tplName}`);
-            } else {
-              relinka("verbose", `Updating template: ${tplName}`);
-            }
-          }
-        } catch (error) {
-          if (error.code !== "ENOENT") {
-            throw error;
-          }
-          relinka("verbose", `Creating new template: ${tplName}`);
-        }
-      } else if (!args.update) {
-        relinka("verbose", `Creating template: ${tplName}`);
-      }
-      const filesWithErrors = Object.entries(filesRecord).filter(([_, meta]) => meta.hasError);
-      if (filesWithErrors.length > 0) {
-        relinka("warn", `Template ${tplName} has files with errors:`);
-        for (const [file, meta] of filesWithErrors) {
-          relinka("warn", `  - ${file}: ${meta.error || "Unknown error"}`);
-        }
-      }
-      await fs.writeFile(templatePath, code.join("\n"));
-      aggregatedImports.push(`import { ${varName} } from "./${TPLS_DIR}/${tplName}";`);
-      aggregatedEntries.push(`  ${tplName}: ${varName},`);
-      mapEntries.push(`  ${varName}: "${tplName}",`);
-    }
-    const WL = args.whitelabel.toUpperCase();
-    const mod = [
-      ...aggregatedImports,
-      "",
-      `const ${WL}_TEMPLATES_OBJ = {`,
-      ...aggregatedEntries,
-      "};",
-      "",
-      `export const ${WL}_TEMPLATES = ${WL}_TEMPLATES_OBJ;`,
-      "",
-      `export type ${WL}_TEMPLATE_NAMES = keyof typeof ${WL}_TEMPLATES;`,
-      "",
-      `export const ${WL.toLowerCase()}TemplatesMap: Record<string, ${WL}_TEMPLATE_NAMES> = {`,
-      ...mapEntries,
-      "};"
-    ];
-    await fs.writeFile(path.join(outDir, modFile), mod.join("\n") + "\n");
-    const templatePaths = templateDirs.map(
-      (tpl) => path.relative(process.cwd(), path.join(outDir, TPLS_DIR, `${tpl}.ts`))
-    );
-    relinka("success", `Packed ${templateDirs.length} templates into ${modFile}:`);
-    for (const p of templatePaths) {
-      relinka("verbose", `- ${p}`);
-    }
-    const binaryCount = Object.values(existingTemplates).reduce((count, template) => {
-      return count + Object.values(template.config.files).filter((file) => file.type === "binary").length;
-    }, 0);
-    if (binaryCount > 0) {
-      relinka("info", `  - ${TPLS_DIR}/${BINARIES_DIR}/* (${binaryCount} binary files)`);
-    }
-  }
-});

package/bin/app/providers/cmd.d.ts

@@ -1,74 +0,0 @@
-declare const _default: import("@reliverse/rempts").Command<{
-    projectName: {
-        type: "string";
-        description: string;
-    };
-    yes: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    database: {
-        type: "string";
-        description: string;
-        allowed: string[];
-    };
-    orm: {
-        type: "string";
-        description: string;
-        allowed: string[];
-    };
-    auth: {
-        type: "boolean";
-        description: string;
-    };
-    frontend: {
-        type: "array";
-        description: string;
-        allowed: string[];
-    };
-    addons: {
-        type: "array";
-        description: string;
-        allowed: string[];
-    };
-    examples: {
-        type: "array";
-        description: string;
-        allowed: string[];
-    };
-    git: {
-        type: "boolean";
-        description: string;
-    };
-    packageManager: {
-        type: "string";
-        description: string;
-        allowed: string[];
-    };
-    install: {
-        type: "boolean";
-        description: string;
-    };
-    dbSetup: {
-        type: "string";
-        description: string;
-        allowed: string[];
-    };
-    backend: {
-        type: "string";
-        description: string;
-        allowed: string[];
-    };
-    runtime: {
-        type: "string";
-        description: string;
-        allowed: string[];
-    };
-    api: {
-        type: "string";
-        description: string;
-        allowed: string[];
-    };
-}>;
-export default _default;