@lobb-js/core 0.13.0

package/src/database/drivers/pgDriver/PGDriver.ts

@@ -0,0 +1,655 @@
+import format from "pg-format";
+import type { FindAllParamsOutput } from "../../../types/index.ts";
+import type {
+  CollectionConfig,
+  CollectionIndex,
+  CollectionIndexes,
+  CollectionsConfig,
+} from "../../../types/index.ts";
+import type { FindAllResult } from "../../../types/index.ts";
+import type { CollectionField } from "../../../types/index.ts";
+
+import pg, { Pool, type PoolClient } from "pg";
+import { DatabaseDriver } from "../../../types/index.ts";
+import { LobbError } from "../../../LobbError.ts";
+import { QueryBuilder } from "./QueryBuilder.ts";
+import { fieldsHasId } from "./utils.ts";
+import { cpus } from "node:os";
+import { Lobb } from "../../../Lobb.ts";
+
+// Parse int8 (bigint) as string to avoid precision loss
+pg.types.setTypeParser(20, (val: string) => val);
+
+// Helper: add Symbol.dispose to a pg PoolClient so `using` syntax works
+function asDisposable<T extends { release(): void }>(client: T): T & Disposable {
+  (client as any)[Symbol.dispose] = () => client.release();
+  return client as T & Disposable;
+}
+
+export class PGDriver extends DatabaseDriver {
+  protected pool!: Pool;
+
+  constructor() {
+    super();
+    // Set databaseConfig here instead of at class field initialization
+    // This avoids the circular dependency at module load time
+    this.databaseConfig = Lobb.instance.configManager.config.database;
+  }
+
+  public async createConnection() {
+    const default_pool_connections = (cpus().length * 2) + 4;
+
+    // Ensure the database exists before connecting
+    await this.ensureDatabaseExists();
+
+    // Now connect to the actual target database
+    this.pool = new Pool({
+      host: this.databaseConfig.host,
+      port: this.databaseConfig.port,
+      user: this.databaseConfig.username,
+      password: this.databaseConfig.password,
+      database: this.databaseConfig.database,
+      max: this.databaseConfig.pool_connections ?? default_pool_connections,
+    });
+  }
+
+  public getConnection() {
+    // Wrap the pool to ensure connections are cleaned IMMEDIATELY after acquiring
+    // This protects against dirty connections left by previous users
+    const originalPool = this.pool;
+
+    return {
+      connect: async () => {
+        const client = await originalPool.connect();
+
+        // CRITICAL FIX: Clean the connection immediately after acquiring from pool
+        // If a previous user left it in a dirty transaction state, we clean it here
+        try {
+          await client.query("ROLLBACK");
+        } catch {
+          // Ignore "no transaction in progress" errors - expected for clean connections
+        }
+
+        return asDisposable(client);
+      },
+    };
+  }
+
+  public async close() {
+    await this.pool.end();
+  }
+
+  public async query<T>(sql: string) {
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const result = await this.runQuery<T>(client, sql);
+    return result.rows;
+  }
+
+  public async dropDatabase() {
+    const tempPool = new Pool({
+      host: this.databaseConfig.host,
+      port: this.databaseConfig.port,
+      user: this.databaseConfig.username,
+      password: this.databaseConfig.password,
+      database: "postgres",
+      max: 1,
+    });
+    try {
+      const client = await tempPool.connect();
+      try {
+        await client.query(format("DROP DATABASE IF EXISTS %I", this.databaseConfig.database));
+      } finally {
+        client.release();
+      }
+    } finally {
+      await tempPool.end();
+    }
+  }
+
+  public async createCollection(
+    collectionName: string,
+    collectionConfig: CollectionConfig,
+  ) {
+    const collectionEntries = Object.entries(collectionConfig.fields);
+    const createTableBodySql: string = collectionEntries.map(
+      ([fieldName, fieldConfig]) => {
+        return `"${fieldName}" ${
+          this.generateFieldSignature(fieldName, fieldConfig)
+        }`;
+      },
+    ).join(", ");
+
+    const query = `CREATE TABLE IF NOT EXISTS ${collectionName} (${createTableBodySql})`;
+
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    await this.runQuery(client, query);
+
+    // creating the indexes
+    const indexes = collectionConfig.indexes;
+    for (
+      const [indexName, value] of Object.entries(indexes)
+    ) {
+      await this.createIndex(
+        collectionName,
+        indexName,
+        value,
+      );
+    }
+  }
+
+  public async dropCollection(collectionName: string) {
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const sql = format("DROP TABLE %I", collectionName);
+    await this.runQuery(client, sql);
+  }
+
+  public async addField(
+    collectionName: string,
+    fieldName: string,
+    field: CollectionField,
+  ): Promise<void> {
+    const sql = `ALTER TABLE ${collectionName}\n      ADD COLUMN ${fieldName} ${
+      this.generateFieldSignature(fieldName, field)
+    }`;
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    await this.runQuery(client, sql);
+  }
+
+  public async removeField(
+    collectionName: string,
+    fieldName: string,
+  ): Promise<void> {
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const sql = `ALTER TABLE ${collectionName} DROP COLUMN ${fieldName}`;
+    await this.runQuery(client, sql);
+  }
+
+  public async getDbSchema(): Promise<CollectionsConfig> {
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const tablesQuery = `
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+    `;
+    const tablesResult = await this.runQuery<{ table_name: string }>(
+      client,
+      tablesQuery,
+    );
+
+    const tableNames: string[] = tablesResult.rows.map((item) =>
+      item.table_name
+    );
+
+    const schema: CollectionsConfig = {};
+    for (let index = 0; index < tableNames.length; index++) {
+      const tableName = tableNames[index];
+      const fieldsQuery = `
+        SELECT column_name, data_type
+        FROM information_schema.columns
+        WHERE table_name = '${tableName}';
+      `;
+      const fieldsInfos = await this.runQuery<
+        { column_name: string; data_type: string }
+      >(client, fieldsQuery);
+
+      const localFields: any = {};
+      for (let index = 0; index < fieldsInfos.rows.length; index++) {
+        const field = fieldsInfos.rows[index];
+        const fieldType = this.getLobbTypeFromPgType(field.data_type);
+        localFields[field.column_name] = {
+          type: fieldType,
+          ...(await this.getFieldDBProperties(
+            fieldType,
+            field.column_name,
+            tableName,
+          )),
+        };
+      }
+
+      schema[tableName] = {
+        indexes: await this.getIndexes(tableName),
+        fields: localFields,
+      };
+    }
+
+    return schema;
+  }
+
+  public async getIdsByFilter(
+    collectionName: string,
+    filter: any,
+    localClient?: PoolClient,
+  ): Promise<string[]> {
+    const where = QueryBuilder.getWhere(filter, collectionName);
+    const query = format(
+      `SELECT id FROM ${collectionName} %s`,
+      where,
+    );
+
+    if (localClient) {
+      const result = await this.runQuery<{ id: string }>(localClient, query);
+      return result.rows.map((row) => row.id);
+    }
+
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const result = await this.runQuery<{ id: string }>(client, query);
+    return result.rows.map((row) => row.id);
+  }
+
+  ////////////////////////
+  // Indexes Operations //
+  ////////////////////////
+  public async createIndex(
+    collectionName: string,
+    indexName: string,
+    indexInfo: CollectionIndex,
+  ) {
+    const indexesFields = Object.entries(indexInfo.fields).map(
+      ([fieldName, fieldOrder]) => {
+        return format("%I %s", fieldName, fieldOrder.order.toUpperCase());
+      },
+    );
+
+    const uniqe = indexInfo.unique ?? false;
+    const query = format(
+      `
+      CREATE ${uniqe ? "UNIQUE" : ""} INDEX IF NOT EXISTS %I
+      ON ${collectionName} (${indexesFields.join(", ")})
+    `,
+      indexName,
+    );
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    await this.runQuery(client, query);
+  }
+
+  public async dropIndex(collectionName: string, indexName: string) {
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const sql = format("DROP INDEX %I", indexName);
+    await this.runQuery(client, sql);
+  }
+
+  public async getIndexes(collectionName: string): Promise<CollectionIndexes> {
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const indexesQuery = `
+      SELECT indexname, indexdef
+      FROM pg_indexes
+      WHERE tablename = '${collectionName}';
+    `;
+    const indexesInfos = await this.runQuery<
+      { indexname: string; indexdef: string }
+    >(client, indexesQuery);
+
+    const dbIndexes = indexesInfos.rows.filter(
+      (index) => index.indexname !== collectionName + "_pkey",
+    );
+
+    const indexes: CollectionIndexes = {};
+
+    for (let index = 0; index < dbIndexes.length; index++) {
+      const dbIndex = dbIndexes[index];
+      indexes[dbIndex.indexname] = this.extractIndexFields(
+        dbIndex.indexdef,
+      );
+    }
+
+    return indexes;
+  }
+
+  private extractIndexFields(indexdef: string) {
+    // Check if the index is unique
+    const isUnique = indexdef.includes("UNIQUE");
+
+    // Regular expression to capture the field names and their order (ASC/DESC)
+    const regex = /\(([^)]+)\)/;
+    const match = indexdef.match(regex);
+
+    const fields: any = {};
+
+    if (match && match[1]) {
+      // Split the field list and clean each part
+      const fieldList = match[1].split(",").map((field) => field.trim());
+
+      // Process each field and determine its order (default to 'asc' if no order is specified)
+      fieldList.forEach((field) => {
+        const parts = field.split(/\s+/); // Split by spaces to handle ASC/DESC
+        const fieldName = parts[0];
+        const order = parts[1] ? parts[1].toLowerCase() : "asc"; // Default to 'asc' if no order is specified
+        fields[fieldName] = { order };
+      });
+    }
+
+    return {
+      unique: isUnique,
+      fields: fields,
+    };
+  }
+
+  /////////////////////
+  // CRUD OPERATIONS //
+  /////////////////////
+  public async findAll(
+    collectionName: string,
+    params: FindAllParamsOutput,
+    localClient?: PoolClient,
+  ): Promise<FindAllResult> {
+    const query = QueryBuilder.build(collectionName, params);
+    const totalCountQuery = QueryBuilder.buildTotalCountQuery(
+      collectionName,
+      params,
+    );
+
+    if (localClient) {
+      return this.runFindAll(localClient, query, totalCountQuery, params);
+    }
+
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    return this.runFindAll(client, query, totalCountQuery, params);
+  }
+
+  private async runFindAll(
+    client: PoolClient,
+    query: string,
+    totalCountQuery: string,
+    params: FindAllParamsOutput,
+  ): Promise<FindAllResult> {
+    const result = await this.runQuery(client, query);
+    const totalCountResult = await this.runQuery<{ count: string }>(
+      client,
+      totalCountQuery,
+    );
+
+    // remove the id if it wasn't selected
+    if (!fieldsHasId(params.fields)) {
+      result.rows = result.rows.map((row: any) => {
+        const { id, ...rest } = row;
+        return rest;
+      });
+    }
+
+    return {
+      data: result.rows as any,
+      meta: {
+        totalCount: Number(totalCountResult.rows[0].count) ?? 0,
+      },
+    };
+  }
+
+  public async createOne(
+    collectionName: string,
+    data: any,
+    localClient?: PoolClient,
+  ) {
+    delete data.id;
+
+    const query = format(
+      `INSERT INTO ${collectionName} (%I) VALUES (%L) RETURNING *`,
+      Object.keys(data),
+      Object.values(data),
+    );
+
+    if (localClient) {
+      const result = await this.runQuery(localClient, query);
+      return result.rows[0] as any;
+    }
+
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    const result = await this.runQuery(client, query);
+    return result.rows[0] as any;
+  }
+
+  public async updateOne(
+    collectionName: string,
+    id: string,
+    data: any,
+    localClient?: PoolClient,
+  ) {
+    const setClause = Object.keys(data).map((key) =>
+      format("%I = %L", key, data[key])
+    ).join(", ");
+
+    const filter = { id };
+    const where = QueryBuilder.getWhere(filter, collectionName);
+    const query = format(
+      `UPDATE ${collectionName} SET ${setClause} %s RETURNING *`,
+      where,
+    );
+
+    if (localClient) {
+      return this.runUpdateOne(localClient, query);
+    }
+
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    return this.runUpdateOne(client, query);
+  }
+
+  private async runUpdateOne(client: PoolClient, query: string) {
+    const result = await this.runQuery(client, query);
+
+    if (!result.rows.length) {
+      throw new LobbError({
+        code: "NOT_FOUND",
+        message: `The record is not found`,
+      });
+    }
+
+    return result.rows[0] as any;
+  }
+
+  public async deleteOne(
+    collectionName: string,
+    id: string,
+    localClient?: PoolClient,
+  ) {
+    const filter = { id };
+    const where = QueryBuilder.getWhere(filter, collectionName);
+    const query = format(
+      `DELETE FROM ${collectionName} %s RETURNING *`,
+      where,
+    );
+
+    if (localClient) {
+      return this.runDeleteOne(localClient, query);
+    }
+
+    const client = asDisposable(await this.pool.connect());
+    using _ = client;
+    return this.runDeleteOne(client, query);
+  }
+
+  private async runDeleteOne(client: PoolClient, query: string) {
+    const result = await this.runQuery(client, query);
+
+    if (!result.rows.length) {
+      throw new LobbError({
+        code: "NOT_FOUND",
+        message: `The record is not found`,
+      });
+    }
+
+    return result.rows[0] as any;
+  }
+
+  /////////////////////
+  // META OPERATIONS //
+  /////////////////////
+  public async getFieldDBProperties(
+    fieldType: string,
+    fieldName: string,
+    collectionName: string,
+  ) {
+    if (fieldType === "string") {
+      const query = format(
+        `
+        SELECT character_maximum_length
+        FROM information_schema.columns
+        WHERE table_name = %L
+        AND column_name = %L;
+      `,
+        collectionName,
+        fieldName,
+      );
+      const client = asDisposable(await this.pool.connect());
+      using _ = client;
+      const result = await this.runQuery<
+        { character_maximum_length: string }
+      >(client, query);
+      return {
+        length: result.rows[0]?.character_maximum_length ?? 255,
+      };
+    }
+
+    return {};
+  }
+
+  ////////////////////
+  // HELPER METHODS //
+  ////////////////////
+  private async ensureDatabaseExists() {
+    // Connect to the 'postgres' database to check if our target database exists
+    const tempPool = new Pool({
+      host: this.databaseConfig.host,
+      port: this.databaseConfig.port,
+      user: this.databaseConfig.username,
+      password: this.databaseConfig.password,
+      database: "postgres", // Connect to default postgres database
+      max: 1, // Only need one connection for this check
+    });
+
+    try {
+      const client = asDisposable(await tempPool.connect());
+      using _ = client;
+
+      // Check if the target database exists
+      const existsQuery = format(
+        "SELECT EXISTS(SELECT 1 FROM pg_database WHERE datname = %L) as exists",
+        this.databaseConfig.database,
+      );
+      const result = await this.runQuery<{ exists: boolean }>(
+        client,
+        existsQuery,
+      );
+
+      const databaseExists = result.rows[0].exists;
+
+      if (!databaseExists) {
+        console.log(
+          `Database '${this.databaseConfig.database}' does not exist. Creating it...`,
+        );
+        const createDbQuery = format(
+          "CREATE DATABASE %I",
+          this.databaseConfig.database,
+        );
+        await this.runQuery(client, createDbQuery);
+        console.log(
+          `Database '${this.databaseConfig.database}' created successfully.`,
+        );
+      }
+    } finally {
+      // Close the temporary connection pool
+      await tempPool.end();
+    }
+  }
+
+  private async runQuery<T = Record<string, unknown>>(
+    client: PoolClient,
+    sql: string,
+  ) {
+    try {
+      return await client.query<T>(sql);
+    } catch (error) {
+      console.error(`[PGDriver] Failed SQL:\n${sql}`);
+      throw error;
+    }
+  }
+
+  private getLobbTypeFromPgType(
+    pgType: string,
+  ): CollectionField["type"] {
+    if (pgType === "character varying") {
+      return "string";
+    } else if (pgType === "text") {
+      return "text";
+    } else if (pgType === "date") {
+      return "date";
+    } else if (pgType === "time with time zone") {
+      return "time";
+    } else if (pgType === "timestamp with time zone") {
+      return "datetime";
+    } else if (pgType === "numeric") {
+      return "decimal";
+    } else if (pgType === "double precision") {
+      return "float";
+    } else if (pgType === "integer") {
+      return "integer";
+    } else if (pgType === "bigint") {
+      return "long";
+    } else if (pgType === "boolean") {
+      return "bool";
+    } else {
+      throw new LobbError({
+        code: "INTERNAL_SERVER_ERROR",
+        message:
+          `The (${pgType}) PG field type is not implemented in getLobbTypeFromPgType`,
+      });
+    }
+  }
+
+  private generateFieldSignature(
+    fieldName: string,
+    fieldConfig: CollectionField,
+  ) {
+    if (fieldName === "id") {
+      return `SERIAL PRIMARY KEY`;
+    } else if (fieldConfig.type === "string") {
+      return `VARCHAR(${fieldConfig.length || 255})`;
+    } else if (fieldConfig.type === "text") {
+      return `TEXT`;
+    } else if (fieldConfig.type === "date") {
+      return `DATE`;
+    } else if (fieldConfig.type === "time") {
+      return `TIMETZ`;
+    } else if (fieldConfig.type === "datetime") {
+      return `TIMESTAMPTZ`;
+    } else if (fieldConfig.type === "decimal") {
+      return `NUMERIC`;
+    } else if (fieldConfig.type === "float") {
+      return `FLOAT`;
+    } else if (fieldConfig.type === "integer") {
+      return `INTEGER`;
+    } else if (fieldConfig.type === "long") {
+      return `BIGINT`;
+    } else if (fieldConfig.type === "bool") {
+      return `BOOLEAN`;
+    }
+
+    throw new LobbError({
+      code: "INTERNAL_SERVER_ERROR",
+      message:
+        `The (${fieldName}) field type is not implemented in generateFieldSignature`,
+    });
+  }
+
+  ///////////////////////////////////////////////////////////
+  // parse some types of data to be compatible with the db //
+  ///////////////////////////////////////////////////////////
+  public override encodeFieldValue(fieldType: string, value: any) {
+    return value;
+  }
+
+  public override decodeFieldValue(fieldType: string, value: any) {
+    return value;
+  }
+}