@skalfa/skalfa-api-core 1.0.2

package/src/commands/runner/blueprint/model-generation.ts

@@ -0,0 +1,149 @@
+import fs from "fs";
+import path from "path";
+import { conversion } from "@utils";
+import { resolveBlueprintPath } from "./runner";
+import { lightModelStub } from "../../stubs";
+
+// ============================>
+// ## Command: blueprint model generation
+// ============================>
+export async function modelGeneration(
+  model: string,
+  schema: Record<string, string> = {},
+  relations: Record<string, string> = {},
+  marker: string
+): Promise<boolean> {
+  const resolvePath = resolveBlueprintPath(model, "model");
+  if (!resolvePath) { return false; }
+
+  const { name, folder, basePath, filePath } = resolvePath;
+  const modelName = conversion.strPascal(name);
+
+  let imports: string[] = [];
+  let importUtils: string[] = ["Field"];
+
+  // ? Fields
+  const fields: string[] = [];
+
+  for (const [name, def] of Object.entries(schema)) {
+    const flags: string[] = [];
+    const typeMatch = /type:(\w+),?(\d+)?/.exec(def);
+    const type = typeMatch?.[1] ?? "string";
+
+    let columnType = "any";
+    switch (type) {
+      case "bigInt":
+      case "bigint":
+      case "bigInteger":
+      case "int":
+      case "integer":
+      case "float":
+        columnType = "number";
+        break;
+      case "string":
+      case "text":
+      case "time":
+        columnType = "string";
+        break;
+      case "date":
+      case "timestamp":
+        columnType = "Date";
+        break;
+      case "json":
+        columnType = "Record<string,any>";
+        break;
+      case "boolean":
+        columnType = "boolean";
+        break;
+      default:
+        columnType = "any";
+        break;
+    }
+
+    if (def.includes("fillable")) flags.push("fillable");
+    if (def.includes("searchable")) flags.push("searchable");
+    if (def.includes("selectable")) flags.push("selectable");
+    if (def.includes("hidden")) flags.push("hidden");
+
+    const decorator = flags.length ? `@Field(${JSON.stringify(flags)})` : "";
+
+    fields.push([
+      `    ${decorator}`,
+      `    ${name}!: ${columnType}`
+    ].join("\n"));
+  }
+
+  // ? Relations
+  const relationFields: string[] = [];
+  
+  let importRelations: string[] = [];
+
+  for (const [name, def] of Object.entries(relations)) {
+    let type = "BelongsTo";
+    let target = conversion.strPascal(def.replace(/\[\]|\[1\]|:/g, "").split(" ")[0].split(",")[0]);
+    const fk = def.split(" ")[0].split(",")[1] || null;
+
+    if (def.startsWith("[]:")) type = "BelongsToMany";
+    else if (def.startsWith("[]")) type = "HasMany";
+    else if (def.startsWith("[1]")) type = "HasOne";
+
+    !importUtils.includes(type) && importUtils.push(type);
+    !importRelations.includes(target) && importRelations.push(`${target}`);
+
+    const isMany = type === "HasMany" || type === "BelongsToMany";
+
+    relationFields.push([
+      ...(type === "BelongsTo" ? [`    ${fk ? fk : conversion.strSnake(target) + "_id"}!: number\n`] : []),
+      `    @${type}(() => ${target}${fk ? `, { foreignKey: "${fk}" }` : ""})`,
+      `    ${name}!: ${isMany ? `${target}[]` : target}`
+    ].join("\n"));
+  }
+
+  if (importRelations.length) {
+    imports.push(`import { ${importRelations.join(", ")} } from '@models'`);
+  }
+
+  let stub = lightModelStub;
+  const strImportUtils = importUtils?.length ? ", " + importUtils.join(", ") : "";
+
+  stub = stub
+    .replace(/{{\s*marker\s*}}/g, marker)
+    .replace(/{{\s*name\s*}}/g, modelName)
+    .replace(/{{\s*fields\s*}}/g, fields.join("\n\n"))
+    .replace(/{{\s*relations\s*}}/g, relationFields.join("\n\n"))
+    .replace(/{{\s*attributes\s*}}/g, "")
+    .replace(/{{\s*import\s*}}/g, imports.join("\n"))
+    .replace(/{{\s*import_utils\s*}}/g, strImportUtils);
+
+  fs.writeFileSync(filePath, stub, "utf-8");
+
+  for (const def of Object.values(relations)) {
+    if (!def.startsWith("[]:")) continue;
+
+    const target = def.replace("[]:", "").trim();
+    generatePivotModel(model, target, marker, basePath);
+  }
+
+  return true;
+}
+
+function generatePivotModel(sourceModel: string, targetModel: string, marker: string, basePath: string) {
+  if (sourceModel > targetModel) return;
+
+  const a = sourceModel.split("/").pop()!;
+  const b = targetModel.split("/").pop()!;
+
+  const pivotModelName = conversion.strPascal(a) + "Has" + conversion.strPascal(b);
+
+  const pivotRelations: Record<string, string> = {
+    [conversion.strSnake(a)]: a,
+    [conversion.strSnake(b)]: b
+  };
+
+  modelGeneration(
+    `${basePath}/${conversion.strSlug(pivotModelName)}`,
+    {},                 
+    pivotRelations,
+    marker
+  );
+}

package/src/commands/runner/blueprint/runner.ts

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { modelGeneration } from "./model-generation";
+import { migrationGeneration } from "./migration-generation";
+import { controllerGeneration } from "./controller-generation";
+import { seederGeneration } from "./seeder-generation";
+import { generateDrawioEntityDocumentation, generateMermaidEntityDocumentation, generatePostmanAPIDocumentation } from "./documentation-generation";
+import { exec as execCb } from "child_process";
+import { promisify } from "util";
+
+const exec = promisify(execCb);
+
+export interface BlueprintSchema {
+  model: string;
+  schema?: Record<string, string>;
+  relations?: Record<string, string>;
+  controllers?: Record<string, string> | false;
+  seeders?: any[][];
+  migrations?: boolean;
+  postman?: boolean;
+  mermaid?: boolean;
+}
+
+const blueprintMarker = `// ============================================
+// ## file THIS FILE IS AUTO-GENERATED BY BLUEPRINT
+// ?? Blueprint : {{ blueprint }}
+// !! If this comment is removed, blueprint engine WILL NOT override this file.
+// ============================================
+
+
+`;
+
+// =====================================>
+// ## Command: blueprint
+// =====================================>
+export const blueprintCommand = new Command("blueprint")
+  .option("-o, --only <names...>", "Run only specific blueprints")
+  .description("Run blueprints")
+  .action(async (opts) => {
+    await runBlueprints({ only: opts.only });
+
+    logger.info("Success run all blueprints!");
+    
+    await exec("bunx barrelsby -c barrels.json", { cwd: path.resolve() });
+
+    logger.info("Success generate auto import all modules!");
+    
+    process.exit(0);
+  });
+
+// =======================>
+// ## Command: Blueprint engine
+// =======================>
+export async function runBlueprints(options?: { only?: string[] }) {
+  const loaded = loadBlueprintFiles();
+  const postmanSchemas: any[] = [];
+
+  for (const file of loaded) {
+    const name = file.file.replace(".blueprint.json", "");
+
+    if (options?.only && !options.only.includes(name)) continue;
+
+    const marker = blueprintMarker.replace(/{{ blueprint }}/g, file.file);
+
+    for (const struct of file.blueprints) {
+      const schema = struct.schema ?? {};
+      const relations = struct.relations ?? {};
+      const seeders = struct.seeders ?? [];
+      const controllers = struct.controllers ?? [];
+
+      await modelGeneration(struct.model, schema, relations, marker);
+
+      if (struct.migrations !== false) {
+        await migrationGeneration(struct.model, schema, relations, marker);
+      }
+
+      if (controllers !== false) {
+        if (Array.isArray(controllers) && !!controllers.length) {
+          controllers.map(async (item: string) => {
+            const [controller, route, permission] = item.split(" ");
+            await controllerGeneration(struct.model, schema, relations, controller, route || controller, permission, marker);
+          });
+        } else {
+          const permission = Math.floor(Math.random() * 1000).toString().padStart(3, "0");
+          await controllerGeneration(struct.model, schema, relations, struct.model, struct.model, permission, marker);
+        }
+
+        if (struct.postman !== false) {
+          const controllerRoutes = Array.isArray(controllers) && controllers.length ? controllers.map(c => {
+            const [controller, route] = c.split(" ");
+            return route || controller;
+          }) : [struct.model];
+
+          postmanSchemas.push({
+            model: struct.model,
+            schema,
+            controllers: controllerRoutes
+          });
+        }
+      }
+
+      if (seeders.length) {
+        await seederGeneration(struct.model, schema, seeders, marker);
+      }
+
+      if (struct.mermaid !== false) {
+        await generateMermaidEntityDocumentation(file.file, file.blueprints);
+      }
+    }
+  }
+
+  await generateDrawioEntityDocumentation(loaded);
+  await generatePostmanAPIDocumentation(postmanSchemas);
+}
+
+// =======================>
+// ## Command: Blueprint load json files
+// =======================>
+function loadBlueprintFiles(dir = "blueprints") {
+  const basePath = path.join(process.cwd(), dir);
+
+  if (!fs.existsSync(basePath)) {
+    throw new Error("Blueprint folder not found");
+  }
+
+  return fs.readdirSync(basePath)
+    .filter(f => f.endsWith(".blueprint.json"))
+    .map(file => {
+      const fullPath = path.join(basePath, file);
+      const content = JSON.parse(fs.readFileSync(fullPath, "utf-8"));
+
+      if (!Array.isArray(content)) {
+        throw new Error(`${file} must export array of blueprints`);
+      }
+
+      return {
+        file,
+        blueprints: content
+      };
+    });
+}
+
+type BlueprintFileType = "model" | "controller";
+
+const TYPE_MAP: Record<BlueprintFileType, { root: string; suffix: string }> = {
+  model: {
+    root: "src/models",
+    suffix: ".model",
+  },
+  controller: {
+    root: "src/controllers",
+    suffix: ".controller",
+  },
+};
+
+export function resolveBlueprintPath(blueprintPath: string, type: BlueprintFileType) {
+  const parts = blueprintPath.split("/").filter(Boolean);
+  const name = parts.pop()!;
+  const folder = parts.join("/");
+  const config = TYPE_MAP[type];
+
+  const basePath = path.join(process.cwd(), config.root, folder);
+  const filePath = path.join(basePath, `${conversion.strSlug(name)}${config.suffix}.ts`);
+
+  if (fs.existsSync(filePath)) {
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    if (!content.includes("AUTO-GENERATED BY BLUEPRINT")) {
+      logger.info(`Skip overridden file: ${filePath}`);
+      return null;
+    }
+  }
+
+  if (!fs.existsSync(basePath)) {
+    fs.mkdirSync(basePath, { recursive: true });
+  }
+
+  return { name, folder, basePath, filePath };
+}

package/src/commands/runner/blueprint/seeder-generation.ts

@@ -0,0 +1,55 @@
+import { conversion, logger } from "@utils";
+import fs from "fs";
+import path from "path";
+import { lightSeederStub } from "../../stubs";
+
+// =================================>
+// ## Command: Blueprint seeder generation
+// =================================>
+export async function seederGeneration(
+  model: string,
+  schema: Record<string, string> = {},
+  data: any[][] = [],
+  marker: string
+): Promise<boolean> {
+  const modelName = conversion.strPascal(model?.split("/")?.pop() || "");
+  const name = modelName + "Seeder";
+  const basePath = path.join(process.cwd(), "src", "database", "seeders");
+  const filename = conversion.strSlug(modelName);
+  const filePath = path.join(basePath, `${filename}.seeder.ts`);
+  
+  if (fs.existsSync(filePath)) {
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    if (!content.includes("AUTO-GENERATED BY BLUEPRINT")) {
+      logger.info(`Skip overridden file: ${filePath}`);
+      return false;
+    }
+  }
+
+  const schemaKeys = Object.keys(schema);
+
+  const seeders = data.map((row) =>
+    `  {${row
+      .map((val, idx) => {
+        const col = schemaKeys[idx];
+        return `"${col}": ${isNaN(val as any) ? `"${val}"` : val}`;
+      })
+    .join(", ")}}`).join(",\n    ");
+
+  let stub = lightSeederStub;
+
+  stub = stub
+    .replace(/{{\s*marker\s*}}/g, marker)
+    .replace(/{{\s*name\s*}}/g, name)
+    .replace(/{{\s*model\s*}}/g, modelName)
+    .replace(/{{\s*seeders\s*}}/g, seeders);
+
+  if (!fs.existsSync(basePath)) {
+    fs.mkdirSync(basePath, { recursive: true });
+  }
+
+  fs.writeFileSync(filePath, stub, "utf-8");
+
+  return true;
+}