@skalfa/skalfa-app 1.0.2 → 1.0.5

package/utils/commands/barrels.ts

@@ -1,28 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { exec } from "child_process";
-import { logger } from "./logger";
-
-const rootDir = path.resolve();
-const configText = fs.readFileSync("barrels.json", "utf8");
-const config = JSON.parse(configText);
-const directories: string[] = Array.isArray(config.directory) ? config.directory : [config.directory];
-
-
-directories.forEach((dir) => {
-  const absoluteDir = path.join(rootDir, dir);
-
-  if (!fs.existsSync(absoluteDir)) {
-    logger.error(`Barrels error: ${absoluteDir} directory not found`)
-    return;
-  }
-
-  fs.watch(absoluteDir, { recursive: true }, (_, filename) => {
-    if (filename && (filename.endsWith(".ts") || filename.endsWith(".tsx")) && filename !== "index.ts") {
-      exec("npx barrelsby -c barrels.json", { cwd: rootDir })
-      logger.info("Barrels updated " + absoluteDir + "/index.ts")
-    }
-  });
-});
-
-logger.start("Barrels watched " + directories.join(", "))

package/utils/commands/blueprint.ts

@@ -1,421 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ValidationRules, conversion } from "@skalfa/skalfa-app-core";
-import { logger } from "./logger";
-
-
-
-type SchemaMap = Record<string, string>
-
-type ColumnItem = {
-  selector  ?:  string
-  label      :  string
-  sortable  ?:  boolean
-  item      ?:  string
-}
-
-type FormItem = {
-  type          ?:  string
-  col           ?:  number
-  construction   :  {
-    name         :  string
-    label        :  string
-    placeholder  :  string
-    validations  :  ValidationRules[]
-    serverOptionControl ?: {
-      path : string
-    }
-    fields ?: FormItem[]
-    wrap  ?: boolean
-  }
-}
-
-type DetailItem = {
-  label  :  string
-  item   :  string
-}
-
-type ParsedSchema = {
-  columns  :  ColumnItem[]
-  forms    :  FormItem[]
-  details  :  DetailItem[]
-}
-
-type BlueprintPage = {
-  features  ?:  string
-  path      ?:  string
-  schema    ?:  Record<string, string>
-}
-
-type BlueprintStruct = {
-  model    :  string
-  controllers ?: string[]
-  schema  ?:  SchemaMap
-  pages   ?:  false | Record<string, BlueprintPage>
-  [key: string]: any
-}
-
-type LoadedBlueprintFile = {
-  file        :  string
-  blueprints  :  BlueprintStruct[]
-}
-
-
-
-const renderJS = (value: unknown, indent = 0): string => {
-  const pad = " ".repeat(indent)
-
-  if (Array.isArray(value)) {
-    if (!value.length) return "[]"
-
-    if (value.every(v => typeof v === "string")) {
-      return `[${value.map(v => JSON.stringify(v)).join(", ")}]`
-    }
-
-    return `[\n${value
-      .map(v => pad + "  " + renderJS(v, indent + 2))
-      .join(",\n")}\n${pad}]`
-  }
-
-  if (value && typeof value === "object") {
-    const entries = Object.entries(value as Record<string, unknown>)
-    if (!entries.length) return "{}"
-
-    return `{\n${entries
-      .map(([k, v]) => `${pad}  ${k}: ${renderJS(v, indent + 2)}`)
-      .join(",\n")}\n${pad}}`
-  }
-
-  if (typeof value === "string") return JSON.stringify(value)
-
-  return String(value)
-}
-
-function extractValidationArray(def: string = ""): ValidationRules[] {
-  const rules: ValidationRules[] = []
-
-  if (def.includes("required")) rules.push("required")
-
-  if (def.includes("email")) rules.push("email")
-
-  if (def.includes("url")) rules.push("url")
-
-  const min = def.match(/min,(\d+)/)
-  if (min) rules.push(`min:${min[1]}`)
-
-  const max = def.match(/max,(\d+)/)
-  if (max) rules.push(`max:${max[1]}`)
-
-  return rules
-}
-
-function extractFormType(rules: string[]): string | undefined {
-  const rule = rules.find(r => r.startsWith("form:"))
-  return rule ? rule.replace("form:", "") : undefined
-}
-
-function inferFormType(pageDef = "", modelDef = ""): string {
-  const explicit = pageDef.split("|")
-  if (explicit && explicit[0] && explicit[0] != "text") return explicit[0]
-
-  if (modelDef.includes("type:integer") || modelDef.includes("type:float")) {
-    return "number"
-  }
-
-  if (modelDef.includes("type:date")) return "date"
-  if (modelDef.includes("type:datetime")) return "datetime"
-  if (modelDef.includes("type:image")) return "image"
-
-  return "default"
-}
-
-function parseFeatures(features?: string): { controlBar: string[]; action: string[] } {
-  const controlBar: string[] = []
-  const action: string[] = []
-
-  if (!features) {
-    return { controlBar: ["CREATE"], action: ["EDIT", "DELETE"] }
-  }
-
-  const list = features.split(" ")
-
-  if (list.includes("create")) controlBar.push("CREATE")
-
-  controlBar.push("SEARCH", "SORT", "SELECTABLE")
-
-  if (list.includes("import")) controlBar.push("IMPORT")
-  if (list.includes("export")) controlBar.push("EXPORT")
-  if (list.includes("print")) controlBar.push("PRINT")
-
-  if (list.includes("update") || list.includes("edit")) action.push("EDIT")
-  if (list.includes("delete")) action.push("DELETE")
-  if (list.includes("detail")) action.push("DETAIL")
-
-  return { controlBar, action }
-}
-
-function parseModelSchema(schema: SchemaMap = {}): ParsedSchema {
-  const columns: ColumnItem[] = []
-  const forms: FormItem[] = []
-  const details: DetailItem[] = []
-
-  for (const [field, def] of Object.entries(schema)) {
-    const label = conversion.strPascal(field, " ")
-
-    if (def.includes("selectable")) {
-      columns.push({ selector: field, label })
-      details.push({ label, item: field })
-    }
-
-    if (def.includes("fillable")) {
-      const fieldType = inferFormType("", def);
-      forms.push({
-        ...(fieldType != "default" ? { type: fieldType } : {}),
-        construction: {
-          name: field,
-          label,
-          placeholder: "Masukkan " + label.toLowerCase(),
-          validations: extractValidationArray(def)
-        }
-      })
-    }
-  }
-
-  return { columns, forms, details }
-}
-
-function resolvePath(page: BlueprintPage, controllers: string[] | boolean | undefined, model: string): string {
-  if (page.path) return page.path
-
-  if (Array.isArray(controllers)) {
-    const match = controllers
-    if (match) return "/" + match[1]
-  }
-
-  return "/" + model.split("/").pop()
-}
-
-function parsePageSchema(pageSchema: Record<string, string>, modelSchema: SchemaMap = {}): ParsedSchema {
-  const columns: ColumnItem[] = []
-  const forms: FormItem[] = []
-  const details: DetailItem[] = []
-
-  for (const [field, def] of Object.entries(pageSchema)) {
-    const rules = def.replace(/\|/g, " ").split(" ").filter(Boolean)
-    
-    const defaultLabel = conversion.strPascal(field, " ")
-    
-    const colLabelRule = rules.find(r => r.includes("column:label,"))
-    const colLabel = conversion.strPascal(colLabelRule ? colLabelRule.split(",")[1] : defaultLabel, " ")
-
-    const formLabelRule = rules.find(r => r.includes("form:label,"))
-    const formLabel = conversion.strPascal(formLabelRule ? formLabelRule.split(",")[1] : (colLabelRule ? colLabel : defaultLabel), " ")
-
-    const detailLabel = colLabelRule ? colLabel : (formLabelRule ? formLabel : defaultLabel) 
-
-    const hasColumn = rules.some(r => r.includes("column:"))
-    const hasForm = rules.some(r => r.includes("form:")) || rules.every(r => !r.includes("column:"))
-    
-    const hasDetail = rules.includes("detail")
-
-    if (hasColumn) {
-      columns.push({
-        selector: field,
-        label: colLabel,
-        ...(rules.includes("column:sortable") || rules.includes("sortable") ? { sortable: true } : {})
-      })
-      if (!hasDetail) details.push({ label: detailLabel, item: field })
-    }
-
-    if (hasForm) {
-      const typeRules = rules.filter(r => !r.startsWith("form:label,"))
-      const typeRule = extractFormType(typeRules)
-      let fieldType = inferFormType(typeRule, modelSchema[field] || "");
-
-      let selectPath = ""
-      const selectRule = rules.find(r => r.startsWith("select,") || r.startsWith("form:select,"))
-      if (selectRule) {
-        fieldType = "select"
-        selectPath = selectRule.split(",")[1]
-      }
-      
-      if (typeRule === "check") fieldType = "boolean" 
-      if (typeRule === "currency") fieldType = "currency"
-      if (typeRule === "image") fieldType = "image"
-      if (typeRule === "date") fieldType = "date"
-      if (typeRule === "time") fieldType = "time"
-      
-      let col: number | undefined
-      const colRule = rules.find(r => /col,(\d+)/.test(r))
-      
-      if (colRule) {
-        const n = Number(colRule.split(',').pop())
-        if (n >= 1 && n <= 12) col = n
-      }
-
-      forms.push({
-        ...(fieldType != "default" && fieldType != "text" ? { type: fieldType } : {}),
-        ...(col ? { col } : {}),
-        construction: {
-          name: field,
-          label: formLabel,
-          placeholder: "Masukkan " + formLabel.toLowerCase(),
-          validations: extractValidationArray(modelSchema[field] || ""),
-          ...(selectPath ? { serverOptionControl: { path: selectPath } } : {}),
-          ...(rules.includes("wrap") ? { wrap: true } : {})
-        }
-      })
-    }
-
-    if (hasDetail) details.push({ label: detailLabel, item: field })
-  }
-
-  const formMap = new Map<string, FormItem>()
-  forms.forEach(f => formMap.set(f.construction.name, f))
-
-  const nestedForms: FormItem[] = []
-
-  forms.forEach(f => {
-    const name = f.construction.name
-    if (name.includes(".")) {
-      const parts = name.split(".")
-      const selfName = parts.pop() as string
-      const parentName = parts.join(".")
-      const parent = formMap.get(parentName)
-
-      if (parent) {
-        if (!parent.type) parent.type = "cluster"
-        if (!parent.construction.fields) parent.construction.fields = []
-        
-        f.construction.name = selfName
-        
-        parent.construction.fields.push(f)
-      } else {
-        nestedForms.push(f)
-      }
-    } else {
-      nestedForms.push(f)
-    }
-  })
-  
-  return { columns, forms: nestedForms, details }
-}
-
-
-
-function loadBlueprintFiles(dir: string = "blueprints"): LoadedBlueprintFile[] {
-  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: file.replace(".blueprint.json", ""),
-        blueprints: content as BlueprintStruct[],
-      }
-    })
-}
-
-const blueprintMarker = `// ============================================
-// ## file THIS FILE IS AUTO-GENERATED BY BLUEPRINT
-// ?? Blueprint : {{ blueprint }}
-// !! If this comment is removed, blueprint engine WILL NOT override this file.
-// ============================================
-
-
-`
-
-
-// ===============================
-// ## Main generator
-// ===============================
-
-export async function blueprint(options?: { only?: string[] }): Promise<void> {
-  const stub = fs.readFileSync(path.join(process.cwd(), "/utils/commands/stubs/table-blueprint.stub"), "utf-8")
-
-  const loaded = loadBlueprintFiles()
-
-  for (const file of loaded) {
-    for (const bp of file.blueprints) {
-
-    const pagesToGenerate: Record<string, BlueprintPage> = { ...(bp.pages || {}) }
-    
-    for (const [key, val] of Object.entries(bp)) {
-      if (typeof val === "object" && val["schema"]) {
-        pagesToGenerate[key] = val as BlueprintPage
-      }
-    }
-
-    for (const [key, page] of Object.entries(pagesToGenerate)) {
-
-      const route = key;
-      const name = conversion.strPascal(route.split("/").pop() as string)
-
-      if (options?.only && !options.only.includes(name)) continue
-
-      const outDir = path.join(process.cwd(), "app", route)
-      fs.mkdirSync(outDir, { recursive: true })
-
-      const filePath = path.join(outDir, "page.tsx");
-
-      if (fs.existsSync(filePath)) {
-        const content = fs.readFileSync(filePath, "utf-8")
-
-        if (!content.includes("AUTO-GENERATED BY BLUEPRINT")) {
-          logger.info(`Skip overridden file: ${filePath}`)
-          continue
-        }
-      }
-
-      const schema = bp.schema ?? {}
-
-      const parsed: ParsedSchema = page?.schema ? parsePageSchema(page.schema, schema) : parseModelSchema(schema)
-
-      const { controlBar, action } = parseFeatures(page?.features)
-
-      const fetchPath = resolvePath(page, bp.controllers, bp.model)
-
-      let properties = `
-        fetchControl={{
-          path: "${fetchPath}" 
-        }}
-          columnControl={${renderJS(parsed.columns, 8)}}
-          formControl={{ 
-            fields: ${renderJS(parsed.forms, 10)} 
-          }}
-        `
-        if (parsed.details) {
-          properties += `  detailControl={${renderJS(parsed.details, 8)}}\n`
-        }
-  
-        if (controlBar.length) {
-          properties += `        controlBar={${JSON.stringify(controlBar)}}\n`
-        }
-  
-        if (action.length) {
-          properties += `        actionControl={${JSON.stringify(action)}}\n`
-        }
-  
-        const content = stub
-          .replace(/{{ marker }}/g, blueprintMarker.replace(/{{ blueprint }}/g, file.file + ".blueprint.json"))
-          .replace(/{{ name }}/g, name)
-          .replace(/{{ title }}/g, name)
-          .replace(/{{ properties }}/g, properties)
-  
-        fs.writeFileSync(path.join(outDir, "page.tsx"), content)
-        logger.info(`Generated: ${filePath}`)
-      }
-    }
-  }
-}

package/utils/commands/light.ts

@@ -1,21 +0,0 @@
-import { Command } from "commander";
-import { usePdf } from "./use-pdf";
-import { blueprint } from "./blueprint";
-import { logger } from "./logger";
-
-const program = new Command();
-
-program.name("light").description("Next Light CLI").version("1.0.0");
-
-program.command("use-pdf").description("Copy pdf.worker.min.mjs ke folder public/").action(usePdf );
-program.command("blueprint")
-    .option("-o, --only <names...>", "Run only specific blueprints")
-    .description("Generate blueprint")
-    .action(async (opts) => {
-        await blueprint({ only: opts.only })
-
-        logger.info("Success run all blueprints!")
-        process.exit(0);
-    });
-
-program.parse();

package/utils/commands/logger.ts

@@ -1,42 +0,0 @@
-/* eslint-disable no-console */
-type LogType = "start" | "info" | "error" | "warning" | "cavity" | "socket" | "cavityError" | "socketError";
-
-const colors: Record<LogType | "default", string> = {
-  default      :  "\x1b[0m",      // default
-  start        :  "\x1b[32m",     // green
-  info         :  "\x1b[36m",     // cyan
-  error        :  "\x1b[31m",     // red
-  warning      :  "\x1b[33m",     // yellow
-  cavity       :  "\x1b[34m",     // blue
-  cavityError  :  "\x1b[31m",     // red
-  socket       :  "\x1b[35m",     // magenta
-  socketError  :  "\x1b[31m",     // red
-};
-
-const prefixes: Record<LogType, string> = {
-  start        :  "START",
-  info         :  "INFO",
-  error        :  "ERROR",
-  warning      :  "WARNING",
-  cavity       :  "CAVITY",
-  socket       :  "SOCKET",
-  cavityError  :  "CAVITY ERROR",
-  socketError  :  "SOCKET ERROR",
-};
-
-function log(type: LogType, ...msg: unknown[]) {
-  const color = colors[type];
-  const prefix = prefixes[type];
-  console.log(`${color}[${prefix}]${colors.default}`, ...msg);
-}
-
-export const logger = {
-  start        :  (...msg: unknown[]) => log("start", ...msg),
-  info         :  (...msg: unknown[]) => log("info", ...msg),
-  error        :  (...msg: unknown[]) => log("error", ...msg),
-  warning      :  (...msg: unknown[]) => log("warning", ...msg),
-  cavity       :  (...msg: unknown[]) => log("cavity", ...msg),
-  cavityError  :  (...msg: unknown[]) => log("cavityError", ...msg),
-  socket       :  (...msg: unknown[]) => log("socket", ...msg),
-  socketError  :  (...msg: unknown[]) => log("socketError", ...msg),
-};

package/utils/commands/stubs/table-blueprint.stub

@@ -1,13 +0,0 @@
-{{ marker }}
-import { TableSupervisionComponent } from "@components";
-
-export default function {{ name }}Page() {
-  return (
-    <>
-      <TableSupervisionComponent
-        title="{{ title }}"
-        {{ properties }}
-      />
-    </>
-  );
-}

package/utils/commands/use-pdf.ts

@@ -1,29 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { logger } from "./logger";
-
-export function usePdf() {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path.dirname(__filename);
-  const projectRoot = path.join(__dirname, "..", "..");
-
-  const source = path.join(
-    projectRoot,
-    "node_modules",
-    "pdfjs-dist",
-    "legacy",
-    "build",
-    "pdf.worker.min.mjs"
-  );
-
-  const target = path.join(projectRoot, "public", "pdf.worker.min.mjs");
-
-  if (!fs.existsSync(source)) {
-    logger.error(`Gagal: pdf.worker.min.mjs tidak ditemukan.`)
-    process.exit(1);
-  }
-
-  fs.copyFileSync(source, target);
-  logger.info("Berhasil memindahkan worker ke public/pdf.worker.min.mjs")
-}