morio_bridge 0.1.0 → 0.1.2

data/server/plugins/lib/schema-converter.ts

@@ -0,0 +1,1393 @@
+/**-------------------------------------------------------------------
+ *
+ *  [ Schema Converter ]
+ *
+ *   - Handles conversion between internal DSL schema and Prisma schema
+ *   - Supports bidirectional conversion (DSL to Prisma and Prisma to DSL)
+ *
+ * -------------------------------------------------------------------*/
+import { plural } from "pluralize";
+import { QUERY } from "./queries";
+
+/**
+ * Converts internal DSL schema to Prisma schema format
+ */
+class DSLToPrismaConverter {
+  constructor() {}
+
+  /**
+   * Convert internal DSL schema to Prisma schema
+   */
+  convertToPrisma(
+    dslSchema: DBConfigs,
+    options: ConversionOptions = {}
+  ): string {
+    const {
+      provider = "postgresql",
+      connectionStringEnv = "DATABASE_URL",
+      includeComments = true,
+    } = options;
+
+    // Start with header and generator
+    let prismaSchema = this.generateHeader(includeComments);
+    prismaSchema += QUERY.SCHEMA_CONVERSION.PRISMA_GENERATOR;
+
+    // Add datasource
+    const datasource = QUERY.SCHEMA_CONVERSION.PRISMA_DATASOURCE.replace(
+      "{provider}",
+      provider
+    ).replace("{connectionStringEnv}", connectionStringEnv);
+    prismaSchema += `\n${datasource}\n`;
+
+    // Process each schema in the DSL
+    const dbName = Object.keys(dslSchema)[0] as string;
+    const schemas = dslSchema[dbName]?.schemas || [];
+
+    // Track relationships to avoid duplicates
+    const processedRelations = new Set<string>();
+
+    // Convert each model
+    for (const schema of schemas) {
+      prismaSchema += this.convertModelToPrisma(
+        schema,
+        schemas,
+        processedRelations,
+        includeComments
+      );
+    }
+
+    return prismaSchema;
+  }
+
+  /**
+   * Generate schema header with comments
+   */
+  private generateHeader(includeComments: boolean): string {
+    if (!includeComments) return "";
+
+    return `// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+`;
+  }
+
+  /**
+   * Convert a single model to Prisma format
+   */
+  private convertModelToPrisma(
+    schema: Schema,
+    allSchemas: Schema[],
+    processedRelations: Set<string>,
+    includeComments: boolean
+  ): string {
+    const modelName = schema.model;
+    let modelDefinition = includeComments
+      ? `// ${schema.tableName} table\n`
+      : "";
+
+    modelDefinition += `model ${modelName} {\n`;
+
+    // Add fields
+    for (const field of schema.fields) {
+      modelDefinition += this.convertFieldToPrisma(field, schema.tableName);
+    }
+
+    // Add relations
+    if (schema.relations) {
+      for (const [relationName, relation] of Object.entries(schema.relations)) {
+        const relationDef = this.convertRelationToPrisma(
+          relationName,
+          relation,
+          schema,
+          allSchemas,
+          processedRelations
+        );
+        if (relationDef) {
+          modelDefinition += relationDef;
+        }
+      }
+    }
+
+    // Add table mapping if table name differs from model name
+    if (schema.tableName.toLowerCase() !== modelName.toLowerCase()) {
+      modelDefinition += `  @@map("${schema.tableName}")\n`;
+    }
+
+    modelDefinition += `}\n\n`;
+    return modelDefinition;
+  }
+
+  /**
+   * Convert a field to Prisma format
+   */
+  private convertFieldToPrisma(field: SchemaField, tableName: string): string {
+    const { name, type } = field;
+    const prismaType = this.mapTypeToPrisma(type, field);
+
+    let fieldDefinition = `  ${name} ${prismaType}`;
+
+    // Handle nullable
+    if (!field.nullable) {
+      fieldDefinition += " ";
+    } else {
+      fieldDefinition += "? ";
+    }
+
+    // Handle primary key
+    if (field.primaryKey) {
+      fieldDefinition += "@id ";
+    }
+
+    // Handle default values
+    if (field.default !== undefined || field.autoIncrement) {
+      fieldDefinition += this.generateDefaultAttribute(field);
+    }
+
+    // Handle unique constraint
+    if (field.unique && !field.primaryKey) {
+      fieldDefinition += "@unique ";
+    }
+
+    // Handle created at
+    if (
+      name.toLowerCase() === "createdat" &&
+      type.toLowerCase().includes("time")
+    ) {
+      fieldDefinition += "@default(now()) ";
+    }
+
+    // Handle updated at
+    if (
+      name.toLowerCase() === "updatedat" &&
+      type.toLowerCase().includes("time")
+    ) {
+      fieldDefinition += "@updatedAt ";
+    }
+
+    // Add column mapping if field name differs from column name in database
+    // This is a placeholder - in a real implementation you'd check if the field name
+    // differs from the column name in the database
+    // if (name !== databaseColumnName) {
+    //   fieldDefinition += `@map("${databaseColumnName}") `;
+    // }
+
+    return `${fieldDefinition}\n`;
+  }
+
+  /**
+   * Generate default attribute for a field
+   */
+  private generateDefaultAttribute(field: SchemaField): string {
+    if (field.autoIncrement) {
+      return "@default(autoincrement()) ";
+    }
+
+    if (
+      field.type.toLowerCase() === "uuid" ||
+      field.name.toLowerCase() === "id"
+    ) {
+      return "@default(uuid()) ";
+    }
+
+    // Handle different types of defaults
+    if (field.default !== undefined) {
+      if (typeof field.default === "string") {
+        return `@default("${field.default}") `;
+      } else if (typeof field.default === "boolean") {
+        return `@default(${field.default}) `;
+      } else if (typeof field.default === "number") {
+        return `@default(${field.default}) `;
+      } else if (field.default === null) {
+        return "";
+      }
+    }
+
+    return "";
+  }
+
+  /**
+   * Convert a relation to Prisma format
+   */
+  private convertRelationToPrisma(
+    relationName: string,
+    relation: SchemaRelation,
+    sourceSchema: Schema,
+    allSchemas: Schema[],
+    processedRelations: Set<string>
+  ): string {
+    const { relatedTo, relationType, foreignKey } = relation;
+
+    // Find the related schema
+    const relatedSchema = allSchemas.find((s) => s.model === relatedTo);
+    if (!relatedSchema) return "";
+
+    // Create a unique identifier for this relation to avoid duplicates
+    const relationId = `${sourceSchema.model}:${relatedSchema.model}:${relationName}`;
+    const reverseRelationId = `${relatedSchema.model}:${sourceSchema.model}:${relationName}`;
+
+    // Skip if we've already processed this relation
+    if (
+      processedRelations.has(relationId) ||
+      processedRelations.has(reverseRelationId)
+    ) {
+      return "";
+    }
+
+    processedRelations.add(relationId);
+
+    // Handle different relation types
+    switch (relationType) {
+      case "OneToOne":
+        return this.generateOneToOneRelation(
+          sourceSchema,
+          relatedSchema,
+          relation,
+          foreignKey
+        );
+
+      case "OneToMany":
+        return this.generateOneToManyRelation(
+          sourceSchema,
+          relatedSchema,
+          relation,
+          foreignKey
+        );
+
+      case "ManyToOne":
+        return this.generateManyToOneRelation(
+          sourceSchema,
+          relatedSchema,
+          relation,
+          foreignKey
+        );
+
+      case "ManyToMany":
+        return this.generateManyToManyRelation(
+          sourceSchema,
+          relatedSchema,
+          relation,
+          relationName
+        );
+
+      default:
+        return "";
+    }
+  }
+
+  /**
+   * Generate a one-to-one relation
+   */
+  private generateOneToOneRelation(
+    sourceSchema: Schema,
+    relatedSchema: Schema,
+    relation: SchemaRelation,
+    foreignKey: string
+  ): string {
+    const relatedModelName = relatedSchema.model;
+    const relationField = this.camelCase(relatedModelName);
+
+    return (
+      `  ${relationField} ${relatedModelName}? @relation(fields: [${foreignKey}], references: [id])\n` +
+      `  ${foreignKey} String? @unique\n`
+    );
+  }
+
+  /**
+   * Generate a one-to-many relation
+   */
+  private generateOneToManyRelation(
+    sourceSchema: Schema,
+    relatedSchema: Schema,
+    relation: SchemaRelation,
+    foreignKey: string
+  ): string {
+    const relatedModelName = relatedSchema.model;
+    const relationField = this.camelCase(plural(relatedModelName));
+
+    return `  ${relationField} ${relatedModelName}[]\n`;
+  }
+
+  /**
+   * Generate a many-to-one relation
+   */
+  private generateManyToOneRelation(
+    sourceSchema: Schema,
+    relatedSchema: Schema,
+    relation: SchemaRelation,
+    foreignKey: string
+  ): string {
+    const relatedModelName = relatedSchema.model;
+    const relationField = this.camelCase(relatedModelName);
+
+    return (
+      `  ${relationField} ${relatedModelName} @relation(fields: [${foreignKey}], references: [id])\n` +
+      `  ${foreignKey} String\n`
+    );
+  }
+
+  /**
+   * Generate a many-to-many relation
+   */
+  private generateManyToManyRelation(
+    sourceSchema: Schema,
+    relatedSchema: Schema,
+    relation: SchemaRelation,
+    relationName: string
+  ): string {
+    const relatedModelName = relatedSchema.model;
+    const relationField = this.camelCase(plural(relatedModelName));
+
+    return `  ${relationField} ${relatedModelName}[] @relation("${relationName}")\n`;
+  }
+
+  /**
+   * Map internal type to Prisma type
+   */
+  private mapTypeToPrisma(type: string, field: SchemaField): string {
+    const typeMap: Record<string, string> = {
+      string: "String",
+      number: "Int",
+      bigint: "BigInt",
+      boolean: "Boolean",
+      Date: "DateTime",
+      DateTime: "DateTime",
+      json: "Json",
+      jsonb: "Json",
+      uuid: "String",
+      text: "String",
+    };
+
+    return typeMap[type.toLowerCase()] || "String";
+  }
+
+  /**
+   * Convert string to camelCase
+   */
+  private camelCase(str: string): string {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+  }
+}
+
+/**
+ * Converts Prisma schema to internal DSL schema format
+ */
+class PrismaToDSLConverter {
+  constructor() {}
+
+  /**
+   * Convert Prisma schema to internal DSL format
+   */
+  convertToDSL(prismaSchema: string, dbName: string): DBConfigs {
+    // Parse the Prisma schema
+    const models = this.parsePrismaSchema(prismaSchema);
+
+    // Convert models to schemas
+    const schemas: Schema[] = models.map((model) =>
+      this.convertModelToDSL(model)
+    );
+
+    // Create the DBConfigs object
+    const dbConfigs: DBConfigs = {
+      [dbName]: {
+        database: {
+          name: dbName,
+          type: this.detectDatabaseType(prismaSchema) as
+            | "postgres"
+            | "sqlite"
+            | "indexeddb"
+            | "memory"
+            | "localstorage"
+            | "valkey",
+          enabled: true,
+          connectionStringEnv: this.extractConnectionStringEnv(prismaSchema),
+        },
+        schemas,
+      },
+    };
+
+    return dbConfigs;
+  }
+
+  /**
+   * Parse Prisma schema into model objects
+   */
+  private parsePrismaSchema(prismaSchema: string): PrismaModel[] {
+    const models: PrismaModel[] = [];
+    const modelRegex = /model\s+(\w+)\s+{([^}]*)}/g;
+    let match;
+
+    while ((match = modelRegex.exec(prismaSchema)) !== null) {
+      const modelName = match[1];
+      const modelBody = match[2];
+
+      // Parse fields
+      const fields: PrismaField[] = [];
+      const relations: PrismaRelation[] = [];
+
+      const lines = modelBody
+        ?.split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line);
+
+      for (const line of lines || []) {
+        // Skip comments and directives
+        if (line.startsWith("//") || line.startsWith("@@")) continue;
+
+        // Parse field
+        const fieldMatch = line.match(/(\w+)\s+(\w+)(\??)(\[\])?(\s+(.*))?/);
+        if (fieldMatch) {
+          const [_, fieldName, fieldType, nullable, isArray, __, attributes] =
+            fieldMatch;
+
+          // Check if it's a relation
+          if (attributes && attributes.includes("@relation")) {
+            const relationMatch = attributes.match(
+              /@relation\(fields:\s*\[(\w+)\],\s*references:\s*\[(\w+)\]\)/
+            );
+            if (relationMatch) {
+              const [_, foreignKey, referencedField] = relationMatch;
+
+              if (foreignKey && referencedField && fieldName && fieldType) {
+                relations.push({
+                  name: fieldName,
+                  type: fieldType,
+                  foreignKey,
+                  referencedField,
+                  isArray: !!isArray,
+                  isRequired: !nullable,
+                });
+              }
+            } else {
+              // Many-to-many relation
+              const manyToManyMatch = attributes.match(/@relation\("(\w+)"\)/);
+              if (manyToManyMatch) {
+                const [_, relationName] = manyToManyMatch;
+
+                if (relationName && fieldName && fieldType) {
+                  relations.push({
+                    name: fieldName,
+                    type: fieldType,
+                    relationName,
+                    isArray: !!isArray,
+                    isRequired: !nullable,
+                  });
+                }
+              }
+            }
+          } else {
+            // Regular field
+            if (fieldName && fieldType) {
+              fields.push({
+                name: fieldName,
+                type: fieldType,
+                isArray: !!isArray,
+                isRequired: !nullable,
+                attributes: attributes || "",
+              });
+            }
+          }
+        }
+      }
+
+      // Extract table name from @@map directive
+      let tableName = modelName;
+      const mapMatch = modelBody?.match(/@@map\("([^"]+)"\)/);
+      if (mapMatch) {
+        tableName = mapMatch[1];
+      }
+
+      if (!tableName) {
+        throw new Error(`Table name not found for model ${modelName}`);
+      }
+
+      if (!modelName) {
+        throw new Error(`Model name not found for model ${modelName}`);
+      }
+
+      models.push({
+        name: modelName,
+        tableName,
+        fields,
+        relations,
+      });
+    }
+
+    return models;
+  }
+
+  /**
+   * Convert a Prisma model to internal DSL schema
+   */
+  private convertModelToDSL(model: PrismaModel): Schema {
+    const fields: SchemaField[] = model.fields.map((field) =>
+      this.convertFieldToDSL(field)
+    );
+    const relations: SchemaRelation[] = [];
+
+    // Convert relations
+    for (const relation of model.relations) {
+      const relationKey = `${relation.name}Relation`;
+      relations.push(this.convertRelationToDSL(relation));
+    }
+
+    return {
+      model: model.name,
+      tableName: model.tableName,
+      fields,
+      relations:
+        Object.keys(relations).length > 0
+          ? relations
+          : ([] as unknown as SchemaRelation[]),
+    };
+  }
+
+  /**
+   * Convert a Prisma field to internal DSL field
+   */
+  private convertFieldToDSL(field: PrismaField): SchemaField {
+    const schemaField: SchemaField = {
+      name: field.name,
+      type: this.mapPrismaTypeToInternal(field.type),
+      nullable: !field.isRequired,
+    };
+
+    // Handle attributes
+    if (field.attributes) {
+      // Primary key
+      if (field.attributes.includes("@id")) {
+        schemaField.primaryKey = true;
+      }
+
+      // Unique constraint
+      if (field.attributes.includes("@unique")) {
+        schemaField.unique = true;
+      }
+
+      // Default values
+      const defaultMatch = field.attributes.match(/@default\(([^)]+)\)/);
+      if (defaultMatch) {
+        const defaultValue = defaultMatch[1];
+
+        if (defaultValue === "autoincrement()") {
+          schemaField.autoIncrement = true;
+        } else if (defaultValue === "uuid()" || defaultValue === "cuid()") {
+          // Handle UUID/CUID default
+          schemaField.default = "uuid";
+        } else if (defaultValue === "now()") {
+          // Handle DateTime default
+          schemaField.DateTime = new Date();
+        } else if (defaultValue === "true" || defaultValue === "false") {
+          // Handle boolean default
+          schemaField.default = defaultValue === "true";
+        } else if (!isNaN(Number(defaultValue))) {
+          // Handle numeric default
+          schemaField.default = Number(defaultValue);
+        } else {
+          // Handle string default (remove quotes)
+          schemaField.default = defaultValue?.replace(/^"(.*)"$/, "$1");
+        }
+      }
+
+      // Updated at
+      // if (field.attributes.includes("@updatedAt")) {
+      //   schemaField.updatedAt = true;
+      // }
+    }
+
+    return schemaField;
+  }
+
+  /**
+   * Convert a Prisma relation to internal DSL relation
+   */
+  private convertRelationToDSL(relation: PrismaRelation): SchemaRelation {
+    let relationType: "OneToOne" | "OneToMany" | "ManyToOne" | "ManyToMany";
+
+    if (relation.isArray) {
+      relationType = relation.relationName ? "ManyToMany" : "OneToMany";
+    } else {
+      relationType =
+        relation.foreignKey && relation.attributes?.includes("@unique")
+          ? "OneToOne"
+          : "ManyToOne";
+    }
+
+    return {
+      relatedTo: relation.type,
+      relationType,
+      foreignKey: relation.foreignKey || "",
+      onDelete: "CASCADE", // Default value, could be extracted from attributes
+    };
+  }
+
+  /**
+   * Map Prisma type to internal type
+   */
+  private mapPrismaTypeToInternal(prismaType: string): string {
+    const typeMap: Record<string, string> = {
+      String: "string",
+      Int: "number",
+      BigInt: "bigint",
+      Float: "number",
+      Decimal: "number",
+      Boolean: "boolean",
+      DateTime: "DateTime",
+      Date: "Date",
+      Json: "json",
+      Bytes: "string",
+    };
+
+    return typeMap[prismaType] || "string";
+  }
+
+  /**
+   * Detect database type from Prisma schema
+   */
+  private detectDatabaseType(prismaSchema: string): string {
+    const providerMatch = prismaSchema.match(/provider\s*=\s*"([^"]+)"/);
+    if (providerMatch && providerMatch[1]) {
+      const provider = providerMatch[1];
+
+      switch (provider) {
+        case "postgresql":
+          return "postgres";
+        case "mysql":
+          return "mysql";
+        case "sqlite":
+          return "sqlite";
+        case "sqlserver":
+          return "sqlserver";
+        default:
+          return provider;
+      }
+    }
+
+    return "postgres"; // Default
+  }
+
+  /**
+   * Extract connection string environment variable from Prisma schema
+   */
+  private extractConnectionStringEnv(prismaSchema: string): string {
+    const urlMatch = prismaSchema.match(/url\s*=\s*env\("([^"]+)"\)/);
+    return urlMatch?.[1] ?? "DATABASE_URL";
+  }
+}
+
+/**
+ * Schema Converter Factory
+ */
+class SchemaConverter {
+  private dslToPrismaConverter: DSLToPrismaConverter;
+  private prismaToDSLConverter: PrismaToDSLConverter;
+
+  constructor() {
+    this.dslToPrismaConverter = new DSLToPrismaConverter();
+    this.prismaToDSLConverter = new PrismaToDSLConverter();
+  }
+
+  /**
+   * Convert DSL schema to Prisma schema
+   */
+  dslToPrisma(dslSchema: DBConfigs, options: ConversionOptions = {}): string {
+    return this.dslToPrismaConverter.convertToPrisma(dslSchema, options);
+  }
+
+  /**
+   * Convert Prisma schema to DSL schema
+   */
+  prismaToDSL(prismaSchema: string, dbName: string): DBConfigs {
+    return this.prismaToDSLConverter.convertToDSL(prismaSchema, dbName);
+  }
+}
+
+/**
+ * Types
+ */
+interface ConversionOptions {
+  provider?: string;
+  connectionStringEnv?: string;
+  includeComments?: boolean;
+}
+
+interface PrismaModel {
+  name: string;
+  tableName: string;
+  fields: PrismaField[];
+  relations: PrismaRelation[];
+}
+
+interface PrismaField {
+  name: string;
+  type: string;
+  isArray: boolean;
+  isRequired: boolean;
+  attributes?: string;
+}
+
+interface PrismaRelation {
+  name: string;
+  type: string;
+  foreignKey?: string;
+  referencedField?: string;
+  relationName?: string;
+  isArray: boolean;
+  isRequired: boolean;
+  attributes?: string;
+}
+
+export { DSLToPrismaConverter, PrismaToDSLConverter, SchemaConverter };
+
+/**
+ * Test
+ */
+
+const DSLSchema: DBConfigs = {
+  uwazi_dev: {
+    database: {
+      name: "uwazi_dev",
+      type: "postgres",
+      enabled: true,
+      connectionStringEnv: "UWAZI_SPRING_DATABASE_URL",
+    },
+    schemas: [
+      {
+        model: "AuditTrail",
+        tableName: "audit_trails",
+        fields: [
+          {
+            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: "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: "Text",
+          },
+        ],
+        relations: [
+          {
+            foreignKey: "treatment_id",
+            relatedTo: "Treatment",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+          },
+          {
+            foreignKey: "hospital_id",
+            relatedTo: "Organisation",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+          },
+          {
+            foreignKey: "insured_id",
+            relatedTo: "Organisation",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+          },
+        ],
+      },
+      {
+        model: "Organisation",
+        tableName: "organisations",
+        fields: [
+          {
+            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: "Text",
+            nullable: true,
+          },
+        ],
+      },
+      {
+        model: "Policy",
+        tableName: "policies",
+        fields: [
+          {
+            name: "policy_number",
+            type: "String",
+            length: 50,
+            unique: true,
+            nullable: false,
+            index: true,
+          },
+          {
+            name: "policy_start_date",
+            type: "Date",
+            nullable: false,
+            default: "now",
+          },
+          {
+            name: "policy_end_date",
+            type: "Date",
+            nullable: false,
+            default: "now",
+          },
+          {
+            name: "premium_amount",
+            type: "Decimal",
+            length: 15,
+            precision: 2,
+            nullable: false,
+          },
+          {
+            name: "remaining_limit",
+            type: "Decimal",
+            nullable: false,
+            length: 15,
+            precision: 2,
+          },
+          {
+            name: "created_at",
+            type: "DateTime",
+            default: "now",
+          },
+          {
+            name: "updated_at",
+            type: "DateTime",
+          },
+        ],
+        relations: [
+          {
+            foreignKey: "user_id",
+            relatedTo: "User",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+          },
+        ],
+      },
+      {
+        model: "Role",
+        tableName: "roles",
+        fields: [
+          {
+            name: "name",
+            type: "String",
+            length: 50,
+            nullable: false,
+          },
+          {
+            name: "description",
+            type: "String",
+            length: 255,
+            nullable: false,
+          },
+          {
+            name: "created_by",
+            type: "String",
+          },
+          {
+            name: "created_at",
+            type: "DateTime",
+            default: "now",
+          },
+        ],
+      },
+      {
+        model: "Token",
+        tableName: "tokens",
+        fields: [
+          {
+            name: "token",
+            type: "Text",
+            nullable: false,
+          },
+          {
+            name: "token_type",
+            type: "String",
+            length: 20,
+            nullable: false,
+          },
+          {
+            name: "expires_at",
+            type: "DateTime",
+            nullable: false,
+          },
+          {
+            name: "revoked",
+            type: "Boolean",
+            default: false,
+          },
+          {
+            name: "created_at",
+            type: "DateTime",
+            default: "now",
+          },
+        ],
+        relations: [
+          {
+            foreignKey: "user_id",
+            relatedTo: "User",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+          },
+        ],
+      },
+      {
+        model: "TreatmentCost",
+        tableName: "treatment_costs",
+        fields: [
+          {
+            name: "hospital_category",
+            type: "String",
+            length: 50,
+            nullable: false,
+          },
+          {
+            name: "min_cost",
+            type: "Decimal",
+            length: 15,
+            precision: 2,
+            nullable: false,
+          },
+          {
+            name: "maximum_cost",
+            type: "Decimal",
+            length: 15,
+            precision: 2,
+            nullable: false,
+          },
+          {
+            name: "created_by",
+            type: "String",
+            length: 100,
+          },
+          {
+            name: "created_at",
+            type: "DateTime",
+            default: "now",
+          },
+          {
+            name: "approved_by",
+            type: "String",
+            length: 100,
+          },
+          {
+            name: "approved_at",
+            type: "DateTime",
+          },
+          {
+            name: "updated_by",
+            type: "String",
+            length: 100,
+          },
+          {
+            name: "updated_at",
+            type: "DateTime",
+          },
+          {
+            name: "status_code",
+            type: "String",
+            length: 50,
+            nullable: false,
+          },
+          {
+            name: "status_description",
+            type: "Text",
+          },
+        ],
+        relations: [
+          {
+            foreignKey: "treatment_id",
+            relatedTo: "Treatment",
+            relationType: "ManyToOne",
+            onDelete: "CASCADE",
+          },
+        ],
+      },
+      {
+        model: "Treatment",
+        tableName: "treatments",
+        fields: [
+          {
+            name: "code",
+            type: "String",
+            length: 50,
+            unique: true,
+            nullable: false,
+            index: true,
+          },
+          {
+            name: "name",
+            type: "String",
+            length: 255,
+          },
+          {
+            name: "description",
+            type: "String",
+            length: 500,
+          },
+          {
+            name: "created_by",
+            type: "String",
+            length: 100,
+          },
+          {
+            name: "created_at",
+            type: "DateTime",
+            default: "now",
+          },
+          {
+            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: "Text",
+          },
+        ],
+      },
+      {
+        model: "User",
+        tableName: "users",
+        fields: [
+          {
+            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: "Date",
+            nullable: true,
+          },
+          {
+            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: "Text",
+            nullable: true,
+          },
+        ],
+        relations: [
+          {
+            foreignKey: "role_id",
+            relatedTo: "Role",
+            relationType: "ManyToOne",
+          },
+          {
+            foreignKey: "organisation_id",
+            relatedTo: "Organisation",
+            relationType: "ManyToOne",
+          },
+        ],
+      },
+    ],
+  },
+};
+
+const schemaConverter = new SchemaConverter();
+const prismaSchema = schemaConverter.dslToPrisma(DSLSchema);
+const dslSchema = schemaConverter.prismaToDSL(prismaSchema, "uwazi_dev");
+await Bun.write("schema.prisma", prismaSchema);
+await Bun.write("dsl-schema.json", JSON.stringify(dslSchema, null, 2));