morio_bridge 0.1.0 → 0.1.2

data/server/plugins/lib/schema.ts

@@ -0,0 +1,469 @@
+import { execSync } from "child_process";
+
+// Prisma scalar types
+type PrismaScalarType =
+  | "String"
+  | "Int"
+  | "BigInt"
+  | "Float"
+  | "Decimal"
+  | "Boolean"
+  | "DateTime"
+  | "Json"
+  | "Bytes";
+
+// DSL field type
+interface DSLField {
+  name: string;
+  type: PrismaScalarType;
+  primaryKey?: boolean;
+  nullable?: boolean;
+  autoIncrement?: boolean;
+  unique?: boolean;
+  default?: string | number | boolean;
+  length?: number;
+  precision?: number;
+  index?: boolean;
+}
+
+// DSL relation type
+interface DSLRelation {
+  foreignKey?: string;
+  relatedTo: string;
+  relationType: "ManyToOne" | "OneToMany" | "OneToOne" | "ManyToMany";
+  onDelete?: "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION";
+  relationName?: string;
+}
+
+// DSL model type
+interface DSLModel {
+  model: string;
+  tableName?: string;
+  fields: DSLField[];
+  relations?: DSLRelation[];
+  indexes?: Record<
+    string,
+    { name: string; fields: string[]; unique?: boolean }
+  >;
+}
+
+// DSL structure
+interface DSL {
+  database: {
+    name: string;
+    type: string;
+    environment?: string;
+    enabled?: boolean;
+    connectionStringEnv: string;
+  };
+  schemas: DSLModel[];
+}
+
+const validatePrismaSchema = (schemaPath: string) => {
+  execSync(`prisma format --schema=${schemaPath}`, { stdio: "inherit" });
+};
+
+// Standalone method to convert DSL to Prisma schema
+const dslToPrismaSchema = async ({
+  dsl,
+  outputPath,
+}: {
+  dsl: DSL;
+  outputPath: string;
+}): Promise<string> => {
+  if (!dsl.database || !dsl.schemas) {
+    throw new Error('Invalid DSL: Missing "database" or "schemas" section');
+  }
+
+  let schema = "";
+
+  schema += `datasource db {\n`;
+  schema += `  provider = "${dsl.database.type}"\n`;
+  schema += `  url      = env("${dsl.database.connectionStringEnv}")\n`;
+  schema += `}\n\n`;
+
+  schema += `generator client {\n`;
+  schema += `  provider = "prisma-client-js"\n`;
+  schema += `}\n\n`;
+
+  dsl.schemas.forEach((model: DSLModel) => {
+    schema += `model ${model.model} {\n`;
+
+    // Fields
+    model.fields.forEach((field: DSLField) => {
+      let fieldDef = `  ${field.name} ${field.type}${
+        field.nullable ? "?" : ""
+      }`;
+
+      if (field.primaryKey) {
+        fieldDef += " @id";
+        if (field.autoIncrement) fieldDef += " @default(autoincrement())";
+      }
+      if (field.unique) fieldDef += " @unique";
+      if (field.default !== undefined) {
+        fieldDef += ` @default(${
+          field.default === "now" ? "now()" : field.default
+        })`;
+      }
+      // Apply length only to String types as VarChar
+      if (field.type === "String" && field.length) {
+        fieldDef += ` @db.VarChar(${field.length})`;
+      }
+      // Apply length and precision to Decimal types
+      if (field.type === "Decimal" && (field.length || field.precision)) {
+        fieldDef += ` @db.Decimal(${field.length || 15}, ${
+          field.precision || 0
+        })`;
+      }
+      if (field.index) {
+        schema += `${fieldDef}\n`;
+        schema += `  @@index([${field.name}])\n`;
+        return;
+      }
+
+      schema += `${fieldDef}\n`;
+    });
+
+    // Relations
+    if (model.relations) {
+      model.relations.forEach((rel: DSLRelation) => {
+        const relationName = rel.relationName
+          ? `"${rel.relationName}"`
+          : undefined;
+        const relatedFieldName = rel.relatedTo.toLowerCase();
+
+        switch (rel.relationType) {
+          case "ManyToOne":
+            schema += `  ${rel.foreignKey} Int\n`;
+            schema += `  ${relatedFieldName} ${rel.relatedTo} @relation(${
+              relationName ? `${relationName}, ` : ""
+            }fields: [${rel.foreignKey}], references: [id]${
+              rel.onDelete ? `, onDelete: ${rel.onDelete}` : ""
+            })\n`;
+            break;
+          case "OneToMany":
+            schema += `  ${relatedFieldName} ${rel.relatedTo}[]${
+              relationName ? ` @relation(${relationName})` : ""
+            }\n`;
+            break;
+          case "OneToOne":
+            if (rel.foreignKey) {
+              schema += `  ${rel.foreignKey} Int @unique\n`;
+              schema += `  ${relatedFieldName} ${rel.relatedTo} @relation(${
+                relationName ? `${relationName}, ` : ""
+              }fields: [${rel.foreignKey}], references: [id]${
+                rel.onDelete ? `, onDelete: ${rel.onDelete}` : ""
+              })\n`;
+            } else {
+              schema += `  ${relatedFieldName} ${rel.relatedTo}?${
+                relationName ? ` @relation(${relationName})` : ""
+              }\n`;
+            }
+            break;
+          case "ManyToMany":
+            throw new Error(
+              "ManyToMany relations require explicit join table definition in DSL"
+            );
+          default:
+            throw new Error(`Unsupported relation type: ${rel.relationType}`);
+        }
+      });
+    }
+
+    // Indexes
+    if (model.indexes) {
+      Object.values(model.indexes).forEach((idx) => {
+        const fields = idx.fields.join(", ");
+        schema += `  @@index([${fields}], name: "${idx.name}"${
+          idx.unique ? ", unique: true" : ""
+        })\n`;
+      });
+    }
+
+    // map table names
+    if (model.tableName) {
+      schema += `  @@map("${model.tableName}")\n`;
+    }
+
+    schema += `}\n\n`;
+  });
+
+  try {
+    await Bun.write(outputPath, schema, { createPath: true });
+    validatePrismaSchema(outputPath);
+  } catch (error: any) {
+    throw new Error(`Failed to format schema: ${error.message}`);
+  }
+
+  return schema;
+};
+
+// Example DSL with inverse OneToMany and custom relation names
+await dslToPrismaSchema({
+  dsl: {
+    database: {
+      name: "uwazi_spring_db",
+      type: "postgres",
+      environment: "prod",
+      enabled: true,
+      connectionStringEnv: "UWAZI_SPRING_DATABASE_URL",
+    },
+    schemas: [
+      {
+        model: "AuditTrail",
+        tableName: "audit_trails",
+        fields: [
+          {
+            name: "id",
+            type: "Int",
+            primaryKey: true,
+            nullable: false,
+            autoIncrement: true,
+          },
+          { name: "log_ref", type: "String", length: 50, nullable: false },
+          { name: "user_name", type: "String", length: 50 },
+          { name: "active_page", type: "String", length: 255 },
+          { name: "activity_done", type: "String", length: 255 },
+          { name: "system_module", type: "String", length: 100 },
+          { name: "audit_date", type: "DateTime", default: "now" },
+          { name: "ip_address", type: "String", length: 50 },
+        ],
+      },
+      {
+        model: "Claim",
+        tableName: "claims",
+        fields: [
+          {
+            name: "id",
+            type: "Int",
+            primaryKey: true,
+            nullable: false,
+            autoIncrement: true,
+          },
+          {
+            name: "claim_reference",
+            type: "String",
+            length: 50,
+            nullable: false,
+            index: true,
+          },
+          {
+            name: "invoice_number",
+            type: "String",
+            length: 50,
+            unique: true,
+            nullable: false,
+            index: true,
+          },
+          { name: "policy_number", type: "String", length: 50 },
+          {
+            name: "invoice_amount",
+            type: "Decimal",
+            nullable: false,
+            length: 15,
+            precision: 2,
+          },
+          { name: "min_cost", type: "Decimal", length: 15, precision: 2 },
+          { name: "maximum_cost", type: "Decimal", length: 15, precision: 2 },
+          { name: "risk_classification", type: "String", length: 50 },
+          { name: "claim_narration", type: "String", length: 500 },
+          { name: "created_by", type: "String", length: 100 },
+          { name: "approved_by", type: "String", length: 100 },
+          { name: "created_at", type: "DateTime", default: "now" },
+          { name: "date_approved", type: "DateTime" },
+          { name: "approval_remarks", type: "String", length: 255 },
+          { name: "status_code", type: "String", length: 50 },
+          { name: "status_description", type: "String" }, // Changed from Text to String
+        ],
+        relations: [
+          {
+            foreignKey: "treatment_id",
+            relatedTo: "Treatment",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+          },
+          {
+            foreignKey: "hospital_id",
+            relatedTo: "Organisation",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+            relationName: "HospitalClaims",
+          },
+          {
+            foreignKey: "insured_id",
+            relatedTo: "Organisation",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+            relationName: "InsuredClaims",
+          },
+        ],
+      },
+      {
+        model: "Organisation",
+        tableName: "organisations",
+        fields: [
+          {
+            name: "id",
+            type: "Int",
+            primaryKey: true,
+            autoIncrement: true,
+            nullable: false,
+          },
+          {
+            name: "code",
+            type: "String",
+            length: 50,
+            unique: true,
+            nullable: false,
+            index: true,
+          },
+          { name: "name", type: "String", length: 255, nullable: false },
+          { name: "type", type: "String", length: 50, nullable: false },
+          { name: "kra_pin", type: "String", length: 50, nullable: true },
+          { name: "head_quarter_location", type: "String", nullable: true },
+          {
+            name: "email_address",
+            type: "String",
+            length: 255,
+            unique: true,
+            nullable: true,
+          },
+          { name: "mobile_number", type: "String", length: 20, nullable: true },
+          {
+            name: "hospital_category",
+            type: "String",
+            length: 50,
+            nullable: true,
+          },
+          { name: "created_at", type: "DateTime", default: "now" },
+          { name: "updated_at", type: "DateTime" },
+          { name: "created_by", type: "String", length: 100 },
+          { name: "approved_by", type: "String", length: 100 },
+          { name: "approved_at", type: "DateTime", default: "now" },
+          { name: "status_code", type: "String", length: 50, nullable: false },
+          { name: "status_description", type: "String", nullable: true }, // Changed from Text to String
+        ],
+        relations: [
+          {
+            relatedTo: "Claim",
+            relationType: "OneToMany",
+            relationName: "HospitalClaims",
+          },
+          {
+            relatedTo: "Claim",
+            relationType: "OneToMany",
+            relationName: "InsuredClaims",
+          },
+          {
+            relatedTo: "User",
+            relationType: "OneToMany",
+            relationName: "OrganisationUsers",
+          },
+        ],
+      },
+      {
+        model: "User",
+        tableName: "users",
+        fields: [
+          {
+            name: "id",
+            type: "Int",
+            primaryKey: true,
+            nullable: false,
+            autoIncrement: true,
+          },
+          {
+            name: "user_name",
+            type: "String",
+            length: 100,
+            unique: true,
+            nullable: false,
+            index: true,
+          },
+          { name: "first_name", type: "String", length: 100, nullable: false },
+          { name: "second_name", type: "String", length: 100, nullable: true },
+          { name: "last_name", type: "String", length: 100, nullable: false },
+          {
+            name: "national_id",
+            type: "String",
+            length: 50,
+            nullable: true,
+            unique: true,
+          },
+          { name: "gender", type: "String", length: 10, nullable: true },
+          { name: "dob", type: "DateTime", nullable: true }, // Changed from Date to DateTime
+          {
+            name: "mobile_number",
+            type: "String",
+            length: 20,
+            unique: true,
+            nullable: true,
+          },
+          {
+            name: "email",
+            type: "String",
+            length: 255,
+            unique: true,
+            nullable: false,
+            index: true,
+          },
+          {
+            name: "password_hash",
+            type: "String",
+            length: 255,
+            nullable: false,
+          },
+          { name: "last_login_date", type: "DateTime", nullable: true },
+          { name: "login_trials", type: "Int", default: 3, nullable: true },
+          { name: "login_ip", type: "String", length: 50, nullable: true },
+          { name: "created_by", type: "String", length: 100, nullable: false },
+          {
+            name: "created_at",
+            type: "DateTime",
+            default: "now",
+            nullable: true,
+          },
+          { name: "approved_by", type: "String", length: 100, nullable: true },
+          {
+            name: "approved_at",
+            type: "DateTime",
+            default: "now",
+            nullable: true,
+          },
+          { name: "updated_at", type: "DateTime", nullable: true },
+          { name: "status_code", type: "String", length: 50, nullable: false },
+          { name: "status_description", type: "String", nullable: true }, // Changed from Text to String
+        ],
+        relations: [
+          {
+            foreignKey: "role_id",
+            relatedTo: "Role",
+            relationType: "ManyToOne",
+          },
+          {
+            foreignKey: "organisation_id",
+            relatedTo: "Organisation",
+            relationType: "ManyToOne",
+            relationName: "OrganisationUsers",
+          },
+        ],
+        indexes: {
+          user_name_email_idx: {
+            name: "user_name_email_idx",
+            fields: ["user_name", "email"],
+            unique: true,
+          },
+          mobile_national_id_idx: {
+            name: "mobile_national_id_idx",
+            fields: ["mobile_number", "national_id"],
+          },
+          login_perf_idx: {
+            name: "login_perf_idx",
+            fields: ["last_login_date", "status_code"],
+          },
+        },
+      },
+    ],
+  },
+  outputPath: "./schema.prisma",
+});

data/server/plugins/lib/util.ts

@@ -0,0 +1,51 @@
+import path from "path";
+import YAML from "yaml";
+
+type ParsedConfig = {
+  parsed: Record<string, any[]>;
+  folder: string;
+  mask: string;
+};
+
+const parseConfigs = async (): Promise<ParsedConfig> => {
+  const configFolder = path.join(process.cwd(), "config");
+  const mask = "**/*{database,.database}.yml";
+
+  // Get all yml files in one glob which accepts database.yml or *.database.yml
+  const glob = new Bun.Glob(mask);
+  const files = await Array.fromAsync(glob.scan(configFolder));
+
+  // Group files by their parent directory
+  const filesByFolder = files.reduce((acc, file) => {
+    const [folder] = file.split("/");
+    if (!folder) return acc;
+
+    if (!acc[folder]) acc[folder] = [];
+    acc[folder].push(file);
+    return acc;
+  }, {} as Record<string, string[]>);
+
+  // Process each folder's files in parallel
+  const results = await Promise.all(
+    Object.entries(filesByFolder).map(async ([folder, files]) => {
+      // Process all files in this folder in parallel
+      const configs = await Promise.all(
+        files.map(async (file) => {
+          const fullPath = path.join(configFolder, file);
+          const content = await Bun.file(fullPath).text();
+          return YAML.parse(content);
+        })
+      );
+      return [folder, configs] as const;
+    })
+  );
+
+  // Convert results back to record
+  return {
+    folder: configFolder,
+    mask,
+    parsed: Object.fromEntries(results),
+  };
+};
+
+export { parseConfigs };

data/server/plugins/orm.ts

@@ -0,0 +1,32 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+
+export class MorioOrm {
+  private prisma: any;
+
+  constructor() {}
+
+  public async init(): Promise<MorioOrm> {
+    // we need to require the prisma client dynamically
+    const connectionString: string = process.env.DATABASE_URL || "";
+    const { PrismaClient } = await import("../db/pg-dev/client");
+    const adapter = new PrismaPg({ connectionString });
+    this.prisma = new PrismaClient({ adapter });
+
+    return this;
+  }
+
+  public async run(options: any) {
+    try {
+      if (!this.prisma) throw new Error("ORM not initialized");
+      return await (this.prisma as any)[options.model][options.action](
+        options.payload
+      );
+    } catch (error) {
+      if (error instanceof Error) {
+        return {
+          error: error.message,
+        };
+      }
+    }
+  }
+}