update seeder

.prettierrc

@@ -0,0 +1,7 @@
+{
+	"printWidth": 5000,
+	"semi": true,
+	"singleQuote": false,
+	"tabWidth": 4,
+	"useTabs": true
+}

config/default.json

@@ -29,4 +29,4 @@
 		"synchronize": true,
 		"logging": true
 	}
-}
+}

package.json

@@ -6,7 +6,11 @@
     "scripts": {
         "dev": "nodemon",
         "build": "tsc",
-        "swagger": "node src/swagger/builder.js"
+        "swagger": "node src/swagger/builder.js",
+        "seeder": "NODE_ENV=default ts-node src/scripts/seed-diagnoses-data.ts",
+        "seeder:default": "NODE_ENV=default ts-node src/scripts/seed-diagnoses-data.ts",
+        "seeder:stag": "NODE_ENV=stag ts-node src/scripts/seed-diagnoses-data.ts",
+        "seeder:prod": "NODE_ENV=prod ts-node src/scripts/seed-diagnoses-data.ts"
     },
     "keywords": [
         "BRI"

src/controllers/diagnosis.ts

@@ -175,7 +175,9 @@ export class DiagnosisController {
 
 			let param: any = await schema.validateAsync(req.params);
 
-			let diagnosis = await DiagnosisModel.list({ "Diagnosis.id": param.id }).then((q) => q.getOne());
+			let diagnosis = await DiagnosisModel.list({
+				"Diagnosis.id": param.id,
+			}).then((q) => q.getOne());
 
 			if (!diagnosis) throw { message: "Diagnosis Not Found" };
 
@@ -232,7 +234,9 @@ export class DiagnosisController {
 			let exist = await DiagnosisModel.list(filter).then((q) => q.getOne());
 			if (exist && exist.id != param.id) throw { message: "Diagnosis " + Language.lang.failed_duplicate };
 
-			let diagnosis = await DiagnosisModel.list({ "Diagnosis.id": param.id }).then((q) => q.getOne());
+			let diagnosis = await DiagnosisModel.list({
+				"Diagnosis.id": param.id,
+			}).then((q) => q.getOne());
 
 			if (!diagnosis) throw { message: "Diagnosis " + Language.lang.failed_not_found };
 
@@ -284,7 +288,9 @@ export class DiagnosisController {
 
 			let affected = 0;
 			if (!param.hard) {
-				let diagnosis: Diagnosis = await DiagnosisModel.list({ "Diagnosis.id": param.id }).then((q) => q.getOne());
+				let diagnosis: Diagnosis = await DiagnosisModel.list({
+					"Diagnosis.id": param.id,
+				}).then((q) => q.getOne());
 
 				if (!diagnosis) throw { message: "Diagnosis " + Language.lang.failed_not_found };
 

src/scripts/seed-diagnoses-data.ts

@@ -0,0 +1,374 @@
+/**
+ * Usage:
+ *   ts-node src/scripts/seed-diagnoses-data.ts
+ *   npm run seeder
+ */
+
+import { ILogObj, Logger } from "tslog";
+import { Diagnosis, DiagnosticProcedure, Status } from "entity";
+import { OrmHelper } from "../helpers/orm";
+import fs from "fs";
+import path from "path";
+
+const log: Logger<ILogObj> = new Logger({
+  name: "[seed-diagnoses-data]",
+  type: "pretty",
+});
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForDbInitialized(timeoutMs: number = 15000) {
+  const start = Date.now();
+  while (!OrmHelper.DB || !OrmHelper.DB.isInitialized) {
+    if (Date.now() - start > timeoutMs) {
+      throw new Error("Database initialization timeout");
+    }
+    await sleep(100);
+  }
+}
+
+async function ensureMasterDataSchemaReady() {
+  // OrmHelper uses `synchronize: true`, so tables should already be created on init.
+  // We only verify the required tables exist before seeding.
+
+  const qr = OrmHelper.DB.createQueryRunner();
+  try {
+    const hasDiagnoses = await qr.hasTable("diagnoses");
+    if (!hasDiagnoses) {
+      throw new Error(
+        'Table "diagnoses" is not available after synchronize()',
+      );
+    }
+
+    const hasDiagnosticProcedures = await qr.hasTable("diagnostic_procedures");
+    if (!hasDiagnosticProcedures) {
+      throw new Error(
+        'Table "diagnostic_procedures" is not available after synchronize()',
+      );
+    }
+  } finally {
+    await qr.release();
+  }
+}
+
+async function upsertDiagnosis(data: {
+  id: string;
+  diagnosis: string;
+  code: string;
+  status?: Status;
+  created_at?: Date | null;
+  created_by?: string | null;
+  updated_at?: Date | null;
+  updated_by?: string | null;
+  deleted_at?: Date | null;
+  deleted_by?: string | null;
+}) {
+  const repo = OrmHelper.DB.getRepository(Diagnosis);
+
+  let row = await repo.findOne({ where: { id: data.id } as any });
+
+  if (!row) {
+    row = new Diagnosis();
+    row.id = data.id;
+    if (data.created_at) {
+      row.created_at = data.created_at;
+    }
+    if (data.created_by !== undefined) {
+      row.created_by = data.created_by ?? null;
+    }
+  }
+
+  row.diagnosis = data.diagnosis;
+  row.code = data.code;
+  row.status = data.status ?? Status.Active;
+  if (data.updated_at) {
+    row.updated_at = data.updated_at;
+  }
+  if (data.updated_by !== undefined) {
+    row.updated_by = data.updated_by ?? null;
+  }
+  if (data.deleted_at !== undefined) row.deleted_at = data.deleted_at ?? null;
+  if (data.deleted_by !== undefined) row.deleted_by = data.deleted_by ?? null;
+
+  return await repo.save(row);
+}
+
+async function upsertDiagnosticProcedure(data: {
+  id: string;
+  diagnosticProcedure: string;
+  code: string;
+  status?: Status;
+  created_at?: Date | null;
+  created_by?: string | null;
+  updated_at?: Date | null;
+  updated_by?: string | null;
+  deleted_at?: Date | null;
+  deleted_by?: string | null;
+}) {
+  const repo = OrmHelper.DB.getRepository(DiagnosticProcedure);
+
+  let row = await repo.findOne({ where: { id: data.id } as any });
+
+  if (!row) {
+    row = new DiagnosticProcedure();
+    row.id = data.id;
+    if (data.created_at) {
+      row.created_at = data.created_at;
+    }
+    if (data.created_by !== undefined) {
+      row.created_by = data.created_by ?? null;
+    }
+  }
+
+  row.diagnosticProcedure = data.diagnosticProcedure;
+  row.code = data.code;
+  row.status = data.status ?? Status.Active;
+  if (data.updated_at) {
+    row.updated_at = data.updated_at;
+  }
+  if (data.updated_by !== undefined) {
+    row.updated_by = data.updated_by ?? null;
+  }
+  if (data.deleted_at !== undefined) row.deleted_at = data.deleted_at ?? null;
+  if (data.deleted_by !== undefined) row.deleted_by = data.deleted_by ?? null;
+
+  return await repo.save(row);
+}
+
+function isUuid(value: any) {
+  return (
+    typeof value === "string" &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+      value,
+    )
+  );
+}
+
+function parseStatus(value: any): Status {
+  if (value === Status.Active || value === Status["Not Active"]) {
+    return value as Status;
+  }
+  if (value === "Y") return Status.Active;
+  if (value === "N") return Status["Not Active"];
+  return Status.Active;
+}
+
+function parseNullableString(value: any) {
+  if (value === undefined || value === null) return null;
+  const s = String(value).trim();
+  return s === "" ? null : s;
+}
+
+function parseNullableDate(value: any): Date | null {
+  if (value === undefined || value === null) return null;
+  const s = String(value).trim();
+  if (s === "" || s.toLowerCase() === "null") return null;
+  const d = new Date(s);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+function escapeRegex(value: string) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function listSeedJsonFiles(seedDir: string, prefix: string) {
+  // Match strictly: "<prefix><timestamp>.json" to avoid overlap
+  // e.g. "users_" should not match "users_roles_user_roles_..."
+  const pattern = new RegExp(`^${escapeRegex(prefix)}\\d+\\.json$`);
+  const files = fs.readdirSync(seedDir).filter((f) => pattern.test(f));
+  files.sort();
+  return files.map((f) => path.join(seedDir, f));
+}
+
+async function readJsonFile<T = any>(filePath: string): Promise<T> {
+  const raw = await fs.promises.readFile(filePath, "utf8");
+  return JSON.parse(raw) as T;
+}
+
+async function main() {
+  OrmHelper.setup();
+  await waitForDbInitialized();
+
+  try {
+    log.info("Starting seed diagnoses data...");
+    await ensureMasterDataSchemaReady();
+
+    // Source of truth for diagnoses seed (JSON exports)
+    const seedDir = path.resolve(process.cwd(), "seed", "diagnoses");
+
+    // IMPORTANT:
+    // Seeder must be 100% synchronized with seed/diagnoses.
+    // That means we process *all* JSON files in this folder (not only the latest export).
+    const expectedPrefixes = [
+      "diagnoses_",
+      "diagnostic_procedures_",
+    ] as const;
+
+    const allJsonFiles = fs
+      .readdirSync(seedDir)
+      .filter((f) => f.endsWith(".json"))
+      .sort();
+    if (allJsonFiles.length === 0) {
+      throw new Error(`No JSON seed files found in ${seedDir}`);
+    }
+
+    const filesByPrefix: Record<(typeof expectedPrefixes)[number], string[]> = {
+      diagnoses_: listSeedJsonFiles(seedDir, "diagnoses_"),
+      diagnostic_procedures_: listSeedJsonFiles(seedDir, "diagnostic_procedures_"),
+    };
+
+    for (const prefix of expectedPrefixes) {
+      if (filesByPrefix[prefix].length === 0) {
+        throw new Error(`Seed file not found: ${prefix}*.json in ${seedDir}`);
+      }
+    }
+
+    const recognized = new Set<string>();
+    for (const prefix of expectedPrefixes) {
+      for (const fp of filesByPrefix[prefix]) recognized.add(path.basename(fp));
+    }
+    const unrecognized = allJsonFiles.filter((f) => !recognized.has(f));
+    if (unrecognized.length > 0) {
+      // Fail fast so we never silently miss new seed files.
+      throw new Error(
+        `Unrecognized seed/diagnoses files: ${unrecognized.join(", ")}`,
+      );
+    }
+
+    log.info("Using seed/diagnoses files:", {
+      diagnoses: filesByPrefix["diagnoses_"].map((f) => path.basename(f)),
+      diagnostic_procedures: filesByPrefix["diagnostic_procedures_"].map((f) =>
+        path.basename(f),
+      ),
+      total_files: allJsonFiles.length,
+    });
+
+    // diagnoses
+    let diagnosesTotal = 0;
+    for (const fileDiagnoses of filesByPrefix["diagnoses_"]) {
+      const doc = await readJsonFile<{ diagnoses?: any[] }>(fileDiagnoses);
+      const rows = Array.isArray(doc?.diagnoses) ? doc.diagnoses : null;
+      if (!rows) {
+        throw new Error(
+          `Invalid JSON structure for diagnoses: ${path.basename(fileDiagnoses)}`,
+        );
+      }
+
+      let processed = 0;
+      for (const row of rows) {
+        const id = parseNullableString(row.id);
+        if (!id) {
+          throw new Error(
+            `Invalid diagnosis row (missing id) in ${path.basename(fileDiagnoses)}`,
+          );
+        }
+        if (!isUuid(id)) {
+          throw new Error(
+            `Invalid diagnosis id (not uuid): ${id} in ${path.basename(fileDiagnoses)}`,
+          );
+        }
+
+        const diagnosis = parseNullableString(row.diagnosis);
+        const code = parseNullableString(row.code);
+        if (!diagnosis || !code) {
+          throw new Error(
+            `Invalid diagnosis row (missing diagnosis/code) id=${id} in ${path.basename(fileDiagnoses)}`,
+          );
+        }
+
+        await upsertDiagnosis({
+          id,
+          diagnosis,
+          code,
+          status: parseStatus(row.status),
+          created_at: parseNullableDate(row.created_at),
+          created_by: parseNullableString(row.created_by),
+          updated_at: parseNullableDate(row.updated_at),
+          updated_by: parseNullableString(row.updated_by),
+          deleted_at: parseNullableDate(row.deleted_at),
+          deleted_by: parseNullableString(row.deleted_by),
+        });
+        processed++;
+      }
+      diagnosesTotal += processed;
+      log.info("Seeded diagnoses file", {
+        file: path.basename(fileDiagnoses),
+        rows: processed,
+      });
+    }
+
+    // diagnostic_procedures
+    let proceduresTotal = 0;
+    for (const fileProcedures of filesByPrefix["diagnostic_procedures_"]) {
+      const doc = await readJsonFile<{ diagnostic_procedures?: any[] }>(
+        fileProcedures,
+      );
+      const rows = Array.isArray(doc?.diagnostic_procedures)
+        ? doc.diagnostic_procedures
+        : null;
+      if (!rows) {
+        throw new Error(
+          `Invalid JSON structure for diagnostic_procedures: ${path.basename(fileProcedures)}`,
+        );
+      }
+
+      let processed = 0;
+      for (const row of rows) {
+        const id = parseNullableString(row.id);
+        if (!id) {
+          throw new Error(
+            `Invalid diagnostic_procedure row (missing id) in ${path.basename(fileProcedures)}`,
+          );
+        }
+        if (!isUuid(id)) {
+          throw new Error(
+            `Invalid diagnostic_procedure id (not uuid): ${id} in ${path.basename(fileProcedures)}`,
+          );
+        }
+
+        const diagnosticProcedure = parseNullableString(row.diagnosticProcedure);
+        const code = parseNullableString(row.code);
+        if (!diagnosticProcedure || !code) {
+          throw new Error(
+            `Invalid diagnostic_procedure row (missing diagnosticProcedure/code) id=${id} in ${path.basename(fileProcedures)}`,
+          );
+        }
+
+        await upsertDiagnosticProcedure({
+          id,
+          diagnosticProcedure,
+          code,
+          status: parseStatus(row.status),
+          created_at: parseNullableDate(row.created_at),
+          created_by: parseNullableString(row.created_by),
+          updated_at: parseNullableDate(row.updated_at),
+          updated_by: parseNullableString(row.updated_by),
+          deleted_at: parseNullableDate(row.deleted_at),
+          deleted_by: parseNullableString(row.deleted_by),
+        });
+        processed++;
+      }
+      proceduresTotal += processed;
+      log.info("Seeded diagnostic_procedures file", {
+        file: path.basename(fileProcedures),
+        rows: processed,
+      });
+    }
+
+    log.info("Seed diagnoses data summary", {
+      diagnoses_rows: diagnosesTotal,
+      diagnostic_procedures_rows: proceduresTotal,
+      files_processed: allJsonFiles.length,
+    });
+
+    log.info("✅ Seed diagnoses data completed");
+    process.exit(0);
+  } catch (error) {
+    log.error("Fatal error:", error);
+    process.exit(1);
+  }
+}
+
+main();