@skalfa/skalfa-api-core 1.0.2

package/src/commands/make/basic-controller.ts

@@ -0,0 +1,49 @@
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { basicControllerStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:controller
+// =====================================>
+export const makeControllerCommand = new Command("make:controller")
+  .argument("<name>", "Name of controller")
+  .description("Create new controller")
+  .action((controllerName) => {
+    const basePath = path.join(process.cwd(), "src", "controllers");
+    
+    if (!controllerName || controllerName.trim() === "") {
+      logger.error("Controller name invalid!");
+      process.exit(1);
+    }
+  
+    const names = controllerName.split("/");
+    const realName = names[names.length - 1];
+    const name = conversion.strPascal(realName) + "Controller";
+    const filename = conversion.strSlug(realName) + ".controller.ts";
+  
+    names.pop();
+    const folder = names.join("/");
+  
+    const filePath = folder ? path.join(basePath, folder, filename) : path.join(basePath, filename);
+  
+    if (existsSync(filePath)) {
+      logger.error("Controller already exists!");
+      process.exit(1);
+    }
+  
+    const targetDir = folder ? path.join(basePath, folder) : basePath;
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+      logger.info(`Create folder ${targetDir}...`);
+    }
+    
+    let content = basicControllerStub;
+    content = content.replace(/{{\s*name\s*}}/g, name || "");
+ 
+    writeFileSync(filePath, content);
+  
+    logger.info(`Controller ${controllerName} created!`);
+    process.exit(0);
+  });

package/src/commands/make/basic-migration.ts

@@ -0,0 +1,89 @@
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { basicMigrationStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:migration
+// =====================================>
+export const makeMigrationCommand = new Command("make:migration")
+  .argument("<name>", "Nama migration")
+  .option("--init", "Buat migration init (0000_00)")
+  .description("Membuat file migration baru")
+  .action((name, options) => {
+    makeMigration(name, options);
+  });
+
+// =====================================>
+// ## Command: migration helpers
+// =====================================>
+export const makeMigration = (
+  migrationName: string,
+  options: { init?: boolean }
+) => {
+  const name = conversion.strSnake(conversion.strPlural(migrationName));
+
+  const now = new Date();
+
+  const baseDir = path.join(
+    process.cwd(),
+    "src",
+    "database",
+    "migrations"
+  );
+
+  let targetDir: string;
+  let fileName: string;
+
+  if (options.init) {
+    targetDir = path.join(baseDir, "0000_00");
+    fileName = `${name}.ts`;
+  } else {
+    const yearMonth = `${now.getFullYear()}_${String(
+      now.getMonth() + 1
+    ).padStart(2, "0")}`;
+
+    targetDir = path.join(baseDir, yearMonth);
+
+    const time = migrationPrefixFile(now);
+    fileName = `${time}_${name}_table.ts`;
+  }
+
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const { className, tableName } = parseName(name);
+
+  let content = basicMigrationStub;
+
+  content = content.replace(/{{\s*className\s*}}/g, className);
+  content = content.replace(/{{\s*tableName\s*}}/g, tableName);
+
+  const filePath = path.join(targetDir, fileName);
+
+  writeFileSync(filePath, content);
+
+  logger.info(`Migration created: ${path.relative(baseDir, filePath)}`);
+
+  process.exit(0);
+};
+
+const migrationPrefixFile = (date: Date) => {
+  const d  =  String(date.getDate()).padStart(2, '0');
+  const h  =  String(date.getHours()).padStart(2, "0");
+  const m  =  String(date.getMinutes()).padStart(2, "0");
+  const s  =  String(date.getSeconds()).padStart(2, "0");
+
+  return `${d}_${h}${m}${s}`;
+};
+
+const parseName = (str: string) => {
+  const parts = str.split('_');
+
+  const className = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+  const tableName = parts.slice(1).join('_');
+
+  return { className, tableName };
+};

package/src/commands/make/basic-model.ts

@@ -0,0 +1,32 @@
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { basicModelStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:model
+// =====================================>
+export const makeModelCommand = new Command("make:model")
+  .argument("<name>", "Name of model")
+  .description("Membuat file model baru")
+  .action((modelName) => {
+    const name = conversion.strPascal(modelName);
+    const filename = conversion.strSlug(modelName) + ".model.ts";
+
+    const filePath = path.join(process.cwd(), "src", "models", filename);
+
+    if (!existsSync(path.dirname(filePath))) {
+      mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+
+    let content = basicModelStub;
+    
+    content = content.replace(/{{\s*name\s*}}/g, name || "");
+
+    writeFileSync(filePath, content);
+
+    logger.info(`Model ${modelName} created!`);
+
+    process.exit(0);
+  });

package/src/commands/make/basic-seeder.ts

@@ -0,0 +1,38 @@
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { basicSeederStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:seeder
+// =====================================>
+export const makeSeederCommand = new Command("make:seeder")
+  .argument("<name>", "Name of seeder")
+  .option("-m, --model <model>", "Attach model to controller")
+  .description("Buat seeder baru")
+  .action((name, options) => {
+    makeSeeder(name, options.model);
+    process.exit(0);
+  });
+
+export const makeSeeder = (seederName: string, model?: string) => {
+  const name = conversion.strPascal(seederName) + "Seeder";
+  const filename = conversion.strSlug(seederName) + ".seeder.ts";
+  const modelName = model || conversion.strPascal(seederName);
+
+  const dir = path.join(process.cwd(), "src", "database", "seeders");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const filePath = path.join(dir, filename);
+  
+  let content = basicSeederStub;
+      
+  content = content
+    .replace(/{{\s*name\s*}}/g, name || "")
+    .replace(/{{\s*model\s*}}/g, modelName || "");
+
+  writeFileSync(filePath, content, { flag: "w" });
+
+  logger.info(`Seeder ${name} created`);
+};

package/src/commands/make/blueprint.ts

@@ -0,0 +1,36 @@
+import path from "path";
+import { writeFileSync, existsSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { blueprintStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:blueprint
+// =====================================>
+export const makeBlueprintCommand = new Command("make:blueprint")
+  .argument("<name>", "Name of blueprint")
+  .description("Create new blueprint")
+  .action((name) => {
+    const basePath = path.join(process.cwd(), "src", "blueprints");
+    
+    if (!name || name.trim() === "") {
+      logger.error("Blueprint name invalid!");
+      process.exit(1);
+    }
+  
+    const filename = conversion.strSlug(name) + ".blueprint.json";
+  
+    const filePath = path.join(basePath, filename);
+  
+    if (existsSync(filePath)) {
+      logger.error("Blueprint already exists!");
+      process.exit(1);
+    }
+    
+    const content = blueprintStub;
+
+    writeFileSync(filePath, content);
+  
+    logger.info(`Blueprint ${filename} created!`);
+    process.exit(0);
+  });

package/src/commands/make/da-migration.ts

@@ -0,0 +1,90 @@
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { Command } from "commander";
+import { logger } from "@utils";
+import { daMigrationStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:da:migration
+// =====================================>
+export const makeDaMigrationCommand = new Command("make:da:migration")
+  .argument("<name>", "Nama migration")
+  .option("--init", "Buat migration init (0000_00)")
+  .description("Membuat file migration baru")
+  .action((name, options) => {
+    makeDaMigration(name, options);
+  });
+
+export const makeDaMigration = (
+  migrationName: string,
+  options: { init?: boolean }
+) => {
+  const name = migrationName.toLowerCase();
+  const now = new Date();
+
+  const baseDir = path.join(
+    process.cwd(),
+    "src",
+    "database",
+    "da.migrations"
+  );
+
+  let targetDir: string;
+  let fileName: string;
+
+  if (options.init) {
+    targetDir = path.join(baseDir, "0000_00");
+    fileName = `${name}.ts`;
+  } else {
+    const yearMonth = `${now.getFullYear()}_${String(
+      now.getMonth() + 1
+    ).padStart(2, "0")}`;
+
+    targetDir = path.join(baseDir, yearMonth);
+
+    const time = migrationPrefixFile(now);
+    fileName = `${time}_${name}_table.ts`;
+  }
+
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const { className, tableName } = parseName(name);
+
+  let content = daMigrationStub;
+
+  content = content.replace(/{{\s*className\s*}}/g, className);
+  content = content.replace(/{{\s*tableName\s*}}/g, tableName);
+
+  const filePath = path.join(targetDir, fileName);
+
+  writeFileSync(filePath, content);
+
+  logger.info(
+    `DA Migration created: ${path.relative(baseDir, filePath)}`
+  );
+
+  process.exit(0);
+};
+
+// =====================================>
+// ## Command: migration helpers
+// =====================================>
+const migrationPrefixFile = (date: Date) => {
+  const d  =  String(date.getDate()).padStart(2, '0');
+  const h  =  String(date.getHours()).padStart(2, "0");
+  const m  =  String(date.getMinutes()).padStart(2, "0");
+  const s  =  String(date.getSeconds()).padStart(2, "0");
+
+  return `${d}_${h}${m}${s}`;
+};
+
+const parseName = (str: string) => {
+  const parts = str.split('_');
+
+  const className = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+  const tableName = parts.slice(1).join('_');
+
+  return { className, tableName };
+};

package/src/commands/make/light-controller.ts

@@ -0,0 +1,67 @@
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { lightControllerStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:light-controller
+// =====================================>
+export const makeLightControllerCommand = new Command("make:light-controller")
+  .argument("<name>", "Name of controller")
+  .option("-m, --model <model>", "Attach model to controller")
+  .description("Make the Light Controller")
+  .action((name, options) => {
+      makeLightController(name, options.model);
+      process.exit(0);
+  });
+
+export const makeLightController = (controllerName: string, modelName?: string) => {
+  const basePath = path.join(process.cwd(), "src", "controllers");
+
+  if (!controllerName || controllerName.trim() === "") {
+    logger.error("Controller name invalid!");
+    process.exit(1);
+  }
+
+  const names = controllerName.split("/");
+  const realName = names[names.length - 1];
+  const name = conversion.strPascal(realName) + "Controller";
+  const filename = conversion.strSlug(realName) + ".controller.ts";
+  const model = modelName || conversion.strPascal(realName);
+
+  names.pop();
+  const folder = names.join("/");
+
+  const filePath = path.join(basePath, filename);
+
+  if (existsSync(filePath)) {
+    logger.error("Controller already exists!");
+    process.exit(1);
+  }
+
+  const targetDir = folder ? path.join(basePath, folder) : basePath;
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+    logger.info(`Create folder ${targetDir}...`);
+  }
+
+  let stub = lightControllerStub;
+
+  stub = stub.replace(
+    /{{\s*name\s*}}|{{\s*model\s*}}|{{\s*validations\s*}}|{{\s*marker\s*}}/g,
+    (match) => {
+      switch (match) {
+        case "{{ name }}":
+          return name;
+        case "{{ model }}":
+          return model;
+        default:
+          return "";
+      }
+    }
+  );
+
+  writeFileSync(filePath, stub);
+  logger.info(`Successfully create light controller: ${filePath}!`);
+};

package/src/commands/make/light-model.ts

@@ -0,0 +1,61 @@
+import path from "path";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { makeLightController } from "./light-controller";
+import { makeMigration } from "./basic-migration";
+import { makeSeeder } from "./basic-seeder";
+import { lightModelStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:light-model
+// =====================================>
+export const makeLightModelCommand = new Command("make:light-model")
+  .argument("<name>", "Name of model")
+  .option("-r", "Generate all resource (controller, migration, seeder)")
+  .description("Make the Light Model")
+  .action((name, options) => {
+    makeLightModel(name);
+
+    if (options.r) {
+      makeLightController(name);
+      makeMigration("create_" + name, { init: true });
+      makeSeeder(name);
+    }
+    
+    process.exit(0);
+  });
+
+export const makeLightModel = (modelName: string) => {
+  const name = conversion.strPascal(modelName);
+  const filename = conversion.strSlug(modelName) + ".model.ts";
+
+  const basePath = path.join(process.cwd(), "src", "models");
+
+  if (!existsSync(basePath)) {
+    mkdirSync(basePath, { recursive: true });
+  }
+
+  const filePath = path.join(basePath, filename);
+
+  if (existsSync(filePath)) {
+    logger.error(`Model ${name} already exists!`);
+    return;
+  }
+
+  let stub = lightModelStub;
+
+  stub = stub
+    .replace(/{{\s*name\s*}}/g, name)
+    .replace(/{{\s*fields\s*}}/g, "")
+    .replace(/{{\s*attributes\s*}}/g, "")
+    .replace(/{{\s*relations\s*}}/g, "")
+    .replace(/{{\s*hooks\s*}}/g, "")
+    .replace(/{{\s*import\s*}}/g, "")
+    .replace(/{{\s*import_utils\s*}}/g, "")
+    .replace(/{{\s*marker\s*}}/g, "");
+
+  writeFileSync(filePath, stub);
+
+  logger.info(`Successfully create light model ${name}!`);
+};

package/src/commands/make/mail.ts

@@ -0,0 +1,51 @@
+import path from "path";
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { mailStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:mail
+// =====================================>
+export const makeMailCommand = new Command("make:mail")
+  .argument("<name>", "Name of mail")
+  .description("Create new mail")
+  .action((name) => {
+    const basePath = path.join(process.cwd(), "src", "outputs", "mails");
+    const templatePath = path.join(process.cwd(), "src", "outputs", "mails", "templates");
+    
+    if (!name || name.trim() === "") {
+      logger.error("Mail name invalid!");
+      process.exit(1);
+    }
+  
+    const filename = conversion.strSlug(name) + ".mail.ts";
+    const templateName = conversion.strSlug(name) + ".mail.stub";
+  
+    const filePath = path.join(basePath, filename);
+  
+    if (existsSync(filePath)) {
+      logger.error("Mail already exists!");
+      process.exit(1);
+    }
+
+    if (!existsSync(basePath)) {
+      mkdirSync(basePath, { recursive: true });
+    }
+    if (!existsSync(templatePath)) {
+      mkdirSync(templatePath, { recursive: true });
+    }
+    
+    let content = mailStub;
+
+    content = content
+      .replace(/{{\s*name\s*}}/g, conversion.strCamel(name) || "")
+      .replace(/{{\s*title\s*}}/g, conversion.strPascal(name, " ") || "");
+
+    writeFileSync(filePath, content);
+    writeFileSync(path.join(templatePath, templateName), "");
+  
+    logger.info(`Mail ${filename} created!`);
+
+    process.exit(0);
+  });

package/src/commands/make/notification.ts

@@ -0,0 +1,43 @@
+import path from "path";
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { notificationStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:notification
+// =====================================>
+export const makeNotificationCommand = new Command("make:notification")
+  .argument("<name>", "Name of notification")
+  .description("Create new notification")
+  .action((name) => {
+    const basePath = path.join(process.cwd(), "src", "outputs", "notifications");
+    
+    if (!name || name.trim() === "") {
+      logger.error("Notification name invalid!");
+      process.exit(1);
+    }
+  
+    const filename = conversion.strSlug(name) + ".notification.ts";
+  
+    const filePath = path.join(basePath, filename);
+  
+    if (existsSync(filePath)) {
+      logger.error("Notification already exists!");
+      process.exit(1);
+    }
+
+    if (!existsSync(basePath)) {
+      mkdirSync(basePath, { recursive: true });
+    }
+    
+    let content = notificationStub;
+
+    content = content.replace(/{{\s*name\s*}}/g, conversion.strCamel(name) || "");
+
+    writeFileSync(filePath, content);
+  
+    logger.info(`Notification ${filename} created!`);
+
+    process.exit(0);
+  });

package/src/commands/make/queue.ts

@@ -0,0 +1,45 @@
+import path from "path";
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { Command } from "commander";
+import { conversion, logger } from "@utils";
+import { queueStub } from "../stubs";
+
+// =====================================>
+// ## Command: make:queue
+// =====================================>
+export const makeQueueCommand = new Command("make:queue")
+  .argument("<name>", "Name of queue")
+  .description("Create new queue")
+  .action((name) => {
+    const basePath = path.join(process.cwd(), "src", "jobs", "queues");
+    
+    if (!name || name.trim() === "") {
+      logger.error("Queue name invalid!");
+      process.exit(1);
+    }
+  
+    const filename = conversion.strSlug(name) + ".queue.worker.ts";
+  
+    const filePath = path.join(basePath, filename);
+  
+    if (existsSync(filePath)) {
+      logger.error("Queue already exists!");
+      process.exit(1);
+    }
+
+    if (!existsSync(basePath)) {
+      mkdirSync(basePath, { recursive: true });
+    }
+    
+    let content = queueStub;
+
+    content = content
+      .replace(/{{\s*name\s*}}/g, conversion.strCamel(name) || "")
+      .replace(/{{\s*worker_name\s*}}/g, conversion.strSlug(name, " ") || "");
+
+    writeFileSync(filePath, content);
+  
+    logger.info(`Queue ${filename} created!`);
+
+    process.exit(0);
+  });