morio_bridge 0.1.0 → 0.1.2

data/server/db/pg-dev/client/models.ts

@@ -0,0 +1,11 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// @ts-nocheck 
+/**
+ * This is a barrel export file for all models and their related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+export type * from './models/User.ts'
+export type * from './commonInputTypes.ts'

data/server/db/pg-dev/schema.prisma

@@ -0,0 +1,24 @@
+generator client {
+  provider        = "prisma-client"
+  previewFeatures = ["queryCompiler", "driverAdapters"]
+  output          = "./client"
+  runtime         = "bun"
+  moduleFormat    = "esm"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(uuid())
+  email     String   
+  password  String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("users")
+}
+
+

data/server/examples/commands.ts

@@ -0,0 +1,95 @@
+import { spawn } from "child_process";
+import kleur from "kleur";
+import path from "path";
+
+const commands = [
+  {
+    command: "prisma migrate reset --schema=./db/pg-dev/schema.prisma --force",
+    verbose: false,
+    label: "orm",
+    description: "resetting database",
+  },
+  {
+    command:
+      "prisma migrate dev --schema=./db/pg-dev/schema.prisma --name=init",
+    verbose: false,
+    label: "orm",
+    description: "running migrations",
+  },
+];
+
+const runCommand = ({
+  command,
+  verbose = true,
+  label = "cmd",
+  description = "",
+}: {
+  command: string;
+  verbose?: boolean;
+  label?: string;
+  description?: string;
+}) => {
+  return new Promise((resolve, reject) => {
+    const commandSplit = command.split(" ");
+    const base = commandSplit[0];
+    const args = commandSplit.slice(1) || [];
+
+    if (!base) {
+      throw new Error("Invalid command");
+    }
+
+    const basePath = path.basename(base);
+
+    // can i catch the error if the command is not found?
+
+    const proc = spawn(base, args, {
+      env: {
+        ...process.env,
+      },
+    });
+
+    if (label && verbose) {
+      const message = `[${label}] ${basePath} ${args.join(" ")}\n`;
+      process.stdout.write(kleur.gray(message));
+    }
+
+    if (label && !verbose && description) {
+      const message = `[${label}] ${description}\n`;
+      process.stdout.write(kleur.gray(message));
+    }
+
+    proc.on("error", (error) => {
+      const message = `[${label}] ${error.message}\n`;
+      process.stderr.write(kleur.red(message));
+    });
+
+    proc.stdout.on("data", (data) => {
+      if (verbose) {
+        process.stdout.write(kleur.gray(data));
+      }
+    });
+
+    proc.stderr.on("data", (data) => {
+      process.stderr.write(kleur.red(data));
+    });
+
+    proc.on("close", (code) => {
+      if (code === 0) {
+        if (verbose) {
+          const message = `[${label}] exited with code ${code}\n`;
+          process.stdout.write(kleur.gray(message));
+        }
+        resolve(true);
+      } else {
+        const message = `[${label}] exited with code ${code}\n`;
+        process.stderr.write(kleur.red(message));
+        // reject(new Error(`Command failed with code ${code}\n`));
+        process.exit(code);
+      }
+    });
+  });
+};
+
+for (const command of commands) {
+  await runCommand(command);
+}

data/server/examples/create-test.ts

@@ -0,0 +1,21 @@
+import { plugins } from "../plugins";
+
+const request = {
+  command: "database",
+  model: "user",
+  action: "create",
+  payload: {
+    data: {
+      email: "johanambuguah@gmail.com",
+      password: "jmm",
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    },
+  },
+};
+
+const response = await plugins
+  .find((plugin: any) => plugin.command && plugin.command === request?.command)
+  ?.run(request);
+
+console.log({ response });

data/server/index.ts

@@ -0,0 +1,349 @@
+import { existsSync, unlinkSync } from "fs";
+import { createServer, Server, Socket } from "net";
+import { plugins } from "./plugins";
+
+interface ParsedRequest {
+  method: string;
+  path: string;
+  body: string;
+}
+
+enum REPLY_TYPE {
+  Health = "health",
+  Invalid = "invalid_request",
+  Error = "internal_server_error",
+  Success = "success",
+}
+
+// Sweet spot server settings( keepalive probe delay and nagle algorithm disabling for lower latency )
+const KEEPALIVE_PROBE_DELAY_MS = 50;
+const DISABLE_NAGLE_ALGORITHM = true;
+
+class UnixSocket {
+  private server: Server | null = null;
+  private bufferSize = 65536; // bytes
+  private isReady: boolean = false;
+
+  constructor(
+    private readonly socketPath: string,
+    private messageHandler: (data: string) => Promise<any>
+  ) {}
+
+  /**
+   * [ Lifecycle]
+   */
+  public async start(): Promise<void> {
+    const maxConnectionAttempts = 20;
+    const retryDelayMs = 50;
+    let connectionAttempts = 0;
+
+    this.createServer();
+
+    while (connectionAttempts < maxConnectionAttempts) {
+      this.deleteSocket(this.socketPath);
+
+      if (connectionAttempts > 0) {
+        const socketName = this.socketPath.split("/").pop();
+        console.log({
+          message: `connecting to ${socketName}`,
+          attempts: connectionAttempts,
+        });
+      }
+
+      try {
+        await new Promise<void>((resolve, reject) => {
+          // server not initialized - retry connection
+          if (!this.server) {
+            reject(new Error("Server not initialized"));
+            return;
+          }
+
+          // server is initialized - listen for connections
+          this.server.listen(this.socketPath, () => {
+            this.isReady = true;
+            resolve();
+          });
+
+          // register error handler - check if the socket file exists
+          // and delete it if it does then retry connection
+          this.server.once("error", (e: any) => {
+            const existsError = e.code === "EEXIST";
+            const socketFileExists = existsSync(this.socketPath);
+
+            if (existsError && socketFileExists) unlinkSync(this.socketPath);
+            reject(e);
+          });
+        });
+        return;
+      } catch (e: any) {
+        if (connectionAttempts < maxConnectionAttempts - 1) {
+          connectionAttempts++;
+          await this.sleep(retryDelayMs);
+          continue;
+        }
+        throw new Error(
+          `Failed to listen on ${this.socketPath} after ${maxConnectionAttempts} attempts: ${e.message}`
+        );
+      }
+    }
+  }
+
+  public stop(): void {
+    this.server?.close();
+    this.isReady = false;
+    this.deleteSocket(this.socketPath);
+  }
+
+  /**
+   * [ message handler ]
+   */
+  private async onMessage(
+    socket: Socket,
+    method: string,
+    path: string,
+    body: string
+  ) {
+    try {
+      const healthCheck = method === "GET" && path === "/health";
+      const invalidRequest = method !== "POST" || path !== "/prisma/0/call";
+
+      switch (true) {
+        case healthCheck:
+          await this.reply({ socket, type: REPLY_TYPE.Health });
+          break;
+        case invalidRequest:
+          await this.reply({ socket, type: REPLY_TYPE.Invalid });
+          break;
+        default:
+          // Success callbacks can be handled here
+          const response = await this.messageHandler(body);
+          await this.reply({
+            socket,
+            type: REPLY_TYPE.Success,
+            body: response,
+          });
+      }
+    } catch (e) {
+      // Error callbacks can be handled here
+      await this.reply({
+        socket,
+        type: REPLY_TYPE.Error,
+        error: e instanceof Error ? e.message : "Unknown error",
+      });
+    }
+  }
+
+  /**
+   * [ unix server socket helpers ]
+   */
+  private createServer() {
+    this.server = createServer(
+      {
+        highWaterMark: this.bufferSize,
+      },
+      (socket: Socket) => {
+        // socket options
+        socket.setEncoding("utf8");
+        socket.setKeepAlive(true, KEEPALIVE_PROBE_DELAY_MS);
+        socket.setNoDelay(DISABLE_NAGLE_ALGORITHM);
+
+        this.setupSocketListeners(socket);
+      }
+    );
+  }
+
+  private async setupSocketListeners(socket: Socket): Promise<void> {
+    // buffer incoming data
+    let buffer = "";
+
+    socket.on("data", async (data: string) => {
+      buffer += data;
+
+      const done = buffer.includes("\r\n\r\n");
+      if (!done) return;
+      const { method, path, body } = await this.fromSocketFormat(buffer);
+
+      await this.onMessage(socket, method, path, body);
+
+      // reset buffer
+      buffer = "";
+    });
+
+    socket.on("error", (e: Error) => {
+      console.error(
+        `Socket error on ${this.socketPath}: ${e.message}, stack: ${e.stack}`
+      );
+    });
+
+    socket.on("drain", () => {
+      socket.resume();
+    });
+
+    socket.on("close", () => {});
+  }
+
+  private deleteSocket(socketPath: string) {
+    // delete the socket if it exists because the server might have crashed
+    // and left the socket file behind
+
+    try {
+      const socketExists = existsSync(socketPath);
+      if (socketExists) unlinkSync(socketPath);
+    } catch (e: any) {
+      if (e.code !== "ENOENT")
+        console.warn(`Failed to delete socket ${socketPath}:`, e);
+    }
+  }
+
+  private sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * [ request/reply helpers ]
+   */
+  private async writeToSocket({
+    socket,
+    code,
+    status,
+    body,
+  }: {
+    socket: Socket;
+    code: number;
+    status: string;
+    body: any;
+  }): Promise<void> {
+    const data = await this.toSocketFormat(code, status, body);
+
+    return new Promise((resolve) => {
+      const isWritable = socket.write(data);
+
+      if (!isWritable) {
+        socket.once("drain", () => {
+          socket.resume();
+          resolve();
+        });
+      } else resolve();
+    });
+  }
+
+  private async reply({
+    socket,
+    type,
+    body,
+    error,
+  }: {
+    socket: Socket;
+    type: REPLY_TYPE;
+    body?: any;
+    error?: string;
+  }) {
+    switch (type) {
+      case REPLY_TYPE.Health:
+        await this.writeToSocket({
+          socket,
+          code: 200,
+          status: "OK",
+          body: { status: "healthy" },
+        });
+        break;
+      case REPLY_TYPE.Invalid:
+        await this.writeToSocket({
+          socket,
+          code: 400,
+          status: "Bad Request",
+          body: { error: "Invalid request" },
+        });
+        break;
+      case REPLY_TYPE.Error:
+        await this.writeToSocket({
+          socket,
+          code: 500,
+          status: "Internal Server Error",
+          body: { error },
+        });
+        break;
+      case REPLY_TYPE.Success:
+        await this.writeToSocket({
+          socket,
+          code: 200,
+          status: "OK",
+          body,
+        });
+        break;
+    }
+  }
+
+  /**
+   * [ socket format helpers ]
+   */
+  private async fromSocketFormat(data: string): Promise<ParsedRequest> {
+    const headerEnd = data.indexOf("\r\n\r\n");
+    if (headerEnd === -1) {
+      throw new Error("Invalid request: no header-body separator");
+    }
+
+    const headers = data.slice(0, headerEnd).split("\r\n");
+    const [method, path] = headers[0]?.split(" ") ?? ["", ""];
+    const body = data.slice(headerEnd + 4);
+    return { method: method ?? "", path: path ?? "", body };
+  }
+
+  private async toSocketFormat(
+    statusCode: number,
+    statusText: string,
+    body: any
+  ): Promise<string> {
+    const bodyStr = await JSON.stringify(body);
+    return `HTTP/1.1 ${statusCode} ${statusText}\r\nContent-Type: application/json\r\nContent-Length: ${bodyStr.length}\r\n\r\n${bodyStr}`;
+  }
+}
+
+class SocketCluster {
+  private servers: UnixSocket[] = [];
+
+  constructor(
+    private readonly config: {
+      socketPaths: string;
+      messageHandler: (body: string) => Promise<any>;
+    }
+  ) {
+    this.servers = this.config.socketPaths
+      .split(",")
+      .map((path) => new UnixSocket(path, this.config.messageHandler));
+  }
+
+  public async init() {
+    for (const server of this.servers) {
+      await server.start();
+    }
+
+    this.servers.forEach((server) => {
+      process.on("SIGTERM", () => {
+        server.stop();
+        process.exit(0);
+      });
+    });
+  }
+}
+
+new SocketCluster({
+  socketPaths: process.env.MORIO_RB_BUN_SOCKETS || "/tmp/prisma.sock",
+  messageHandler: async (body: string) => {
+    const request = await JSON.parse(body);
+
+    const response = plugins
+      .find(
+        (plugin: any) => plugin.command && plugin.command === request?.command
+      )
+      ?.run(request);
+
+    if (response) return response;
+
+    return {
+      from: "bun-server-xxx",
+      request,
+      response: request,
+    };
+  },
+}).init();

data/server/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "unix",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "bun run index.ts",
+    "ptest": "tsx test.ts",
+    "prisma:generate": "prisma generate --schema=./db/pg-dev/schema.prisma",
+    "prisma:studio": "prisma studio",
+    "prisma:migrate:dev": "prisma migrate dev --schema=./db/pg-dev/schema.prisma --name=init",
+    "prisma:migrate:reset": "prisma migrate reset --schema=./db/pg-dev/schema.prisma --force",
+    "prisma:db:pull": "prisma db pull --schema=./db/pg-dev/schema.prisma",
+    "prisma:db:push": "prisma db push --schema=./db/pg-dev/schema.prisma",
+    "prisma:validate": "prisma validate --schema=./db/pg-dev/schema.prisma",
+    "prisma:format": "prisma format --schema=./db/pg-dev/schema.prisma",
+    "prisma:version": "prisma version",
+    "prisma:debug": "prisma debug",
+    "prisma:help": "prisma --help",
+    "to-exe": "bun build --compile --outfile ../unix_server index.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/pg": "8.15.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@prisma/adapter-pg": "6.8.2",
+    "@prisma/client": "6.8.2",
+    "fastest-validator": "1.19.1",
+    "kleur": "^4.1.5",
+    "pg": "8.16.0",
+    "prisma": "6.8.2",
+    "yaml": "^2.8.0"
+  },
+  "trustedDependencies": [
+    "better-sqlite3",
+    "fastest-validator",
+    "pg",
+    "prisma",
+    "@prisma/client",
+    "@prisma/adapter-pg"
+  ]
+}

data/server/plugins/index.ts

@@ -0,0 +1,26 @@
+// import { MorioOrm } from "./orm";
+import { parseConfigs } from "./lib/util";
+import { MorioValidator } from "./validator";
+
+const configs = await parseConfigs();
+
+console.log("Hi, my name is Morio");
+console.log(JSON.stringify({ configs }));
+
+const validator = new MorioValidator();
+// const orm = await new MorioOrm().init();
+
+export const plugins = [
+  {
+    name: "validator",
+    command: "validate",
+    description: "A validator plugin",
+    run: (options: any) => validator.run(options),
+  },
+  // {
+  //   name: "orm",
+  //   command: "database",
+  //   description: "A orm plugin",
+  //   run: (options: any) => orm.run(options),
+  // },
+];

data/server/plugins/lib/correct.schema.prisma

@@ -0,0 +1,131 @@
+datasource db {
+  provider = "postgres"
+  url      = env("UWAZI_SPRING_DATABASE_URL")
+}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+model AuditTrail {
+  id Int @id @default(autoincrement())
+  log_ref String @db.VarChar(50)
+  user_name String @db.VarChar(50)
+  active_page String @db.VarChar(255)
+  activity_done String @db.VarChar(255)
+  system_module String @db.VarChar(100)
+  audit_date DateTime @default(now())
+  ip_address String @db.VarChar(50)
+  @@map("audit_trails")
+}
+
+model Treatment {
+  id Int @id @default(autoincrement())
+  claims Claim[]
+  // Add other Treatment fields as needed
+  @@map("treatments")
+}
+
+model Role {
+  id Int @id @default(autoincrement())
+  users User[]
+  // Add other Role fields as needed
+  @@map("roles")
+}
+model Claim {
+  id Int @id @default(autoincrement())
+  claim_reference String @db.VarChar(50)
+  @@index([claim_reference])
+  invoice_number String @unique @db.VarChar(50)
+  @@index([invoice_number])
+  policy_number String @db.VarChar(50)
+  invoice_amount Decimal @db.Decimal(15, 2)
+  min_cost Decimal @db.Decimal(15, 2)
+  maximum_cost Decimal @db.Decimal(15, 2)
+  risk_classification String @db.VarChar(50)
+  claim_narration String @db.VarChar(500)
+  created_by String @db.VarChar(100)
+  approved_by String @db.VarChar(100)
+  created_at DateTime @default(now())
+  date_approved DateTime
+  approval_remarks String @db.VarChar(255)
+  status_code String @db.VarChar(50)
+  status_description String
+  treatment_id Int
+  treatment Treatment @relation(fields: [treatment_id], references: [id], onDelete: Cascade)
+  hospital_id Int
+  hospital_claims Organisation @relation("HospitalClaims", fields: [hospital_id], references: [id], onDelete: Cascade)
+  insured_id Int
+  insurer_claims Organisation @relation("InsuredClaims", fields: [insured_id], references: [id], onDelete: Cascade)
+  @@map("claims")
+}
+
+model Organisation {
+  id Int @id @default(autoincrement())
+  code String @unique @db.VarChar(50)
+  @@index([code])
+  name String @db.VarChar(255)
+  type String @db.VarChar(50)
+  kra_pin String? @db.VarChar(50)
+  head_quarter_location String?
+  email_address String? @unique @db.VarChar(255)
+  mobile_number String? @db.VarChar(20)
+  hospital_category String? @db.VarChar(50)
+  created_at DateTime @default(now())
+  updated_at DateTime
+  created_by String @db.VarChar(100)
+  approved_by String @db.VarChar(100)
+  approved_at DateTime @default(now())
+  status_code String @db.VarChar(50)
+  status_description String?
+  hospital_claims Claim[] @relation("HospitalClaims")
+  insured_claims Claim[] @relation("InsuredClaims")
+  users User[] @relation("OrganisationUsers")
+  @@map("organisations")
+}
+
+model User {
+  id Int @id @default(autoincrement())
+  user_name String @unique @db.VarChar(100)
+  @@index([user_name])
+  first_name String @db.VarChar(100)
+  second_name String? @db.VarChar(100)
+  last_name String @db.VarChar(100)
+  national_id String? @unique @db.VarChar(50)
+  gender String? @db.VarChar(10)
+  dob DateTime?
+  mobile_number String? @unique @db.VarChar(20)
+  email String @unique @db.VarChar(255)
+  @@index([email])
+  password_hash String @db.VarChar(255)
+  last_login_date DateTime?
+  login_trials Int? @default(3)
+  login_ip String? @db.VarChar(50)
+  created_by String @db.VarChar(100)
+  created_at DateTime? @default(now())
+  approved_by String? @db.VarChar(100)
+  approved_at DateTime? @default(now())
+  updated_at DateTime?
+  status_code String @db.VarChar(50)
+  status_description String?
+
+  // relations
+  role_id Int
+  role Role @relation(fields: [role_id], references: [id])
+
+  organisation_id Int
+  organisation Organisation @relation("OrganisationUsers", fields: [organisation_id], references: [id])
+  
+  // indexes
+  @@index([user_name, email], name: "user_name_email_idx")
+  @@unique([user_name, email])
+  
+
+  @@index([mobile_number, national_id], name: "mobile_national_id_idx")
+
+  @@index([last_login_date, status_code], name: "login_perf_idx")
+
+  // mapped
+  @@map("users")
+}
+