opacacms 0.1.0

package/src/db/postgres.ts

@@ -0,0 +1,621 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  CompiledQuery,
+  FileMigrationProvider,
+  Kysely,
+  Migrator,
+  PostgresDialect,
+  sql,
+} from "kysely";
+import postgres from "postgres";
+import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
+import { logger } from "../utils/logger";
+import { BaseDatabaseAdapter } from "./adapter";
+import { flattenPayload, unflattenRow } from "./kysely/data-mapper";
+import { toSnakeCase } from "./kysely/field-mapper";
+import { buildKyselyWhere } from "./kysely/query-builder";
+import { pushSchema } from "./kysely/schema-builder";
+
+export interface PostgresConfig {
+  url?: string;
+  host?: string;
+  port?: number;
+  database?: string;
+  username?: string;
+  password?: string;
+  ssl?: boolean | "require" | "allow" | "prefer" | "verify-full" | Record<string, unknown>;
+}
+
+export class PostgresAdapter extends BaseDatabaseAdapter {
+  override name = "postgres";
+  private _rawDb: postgres.Sql | null = null;
+  private _db: Kysely<any> | null = null;
+  private _collections: Collection[] = [];
+  private _globals: Global[] = [];
+  private config: PostgresConfig | string;
+  override push: boolean;
+  override migrationDir: string;
+  override pushDestructive: boolean;
+
+  override get raw() {
+    return this._rawDb;
+  }
+
+  override get db() {
+    return this._db;
+  }
+
+  constructor(
+    config: PostgresConfig | string,
+    options?: { push?: boolean; pushDestructive?: boolean; migrationDir?: string },
+  ) {
+    super();
+    this.config = config;
+    this.push = options?.push ?? process.env.NODE_ENV !== "production";
+    this.pushDestructive = options?.pushDestructive ?? false;
+    this.migrationDir = options?.migrationDir ?? "./migrations";
+  }
+
+  override async connect(): Promise<void> {
+    if (this._rawDb) return;
+
+    if (typeof this.config === "string") {
+      this._rawDb = postgres(this.config);
+    } else {
+      this._rawDb = postgres({
+        host: this.config.host,
+        port: this.config.port,
+        database: this.config.database,
+        username: this.config.username,
+        password: this.config.password,
+        ssl: this.config.ssl,
+      });
+    }
+
+    this._db = new Kysely<any>({
+      dialect: new PostgresDialect({
+        pool: {
+          connect: async () => {
+            const query = async (sqlStr: string, parameters?: any[]) => {
+              const res = await (this._rawDb as any).unsafe(sqlStr, parameters || []);
+              return { rows: res };
+            };
+            return { query, release: () => {} };
+          },
+          end: async () => {},
+          on: () => {},
+        } as any,
+      }),
+    });
+  }
+
+  override async disconnect(): Promise<void> {
+    if (this._db) await this._db.destroy();
+    if (this._rawDb) await this._rawDb.end();
+    this._db = null;
+    this._rawDb = null;
+  }
+
+  override async unsafe(query: string, params?: unknown[]): Promise<unknown> {
+    if (!this._db) throw new Error("DB not connected");
+    const compiled = CompiledQuery.raw(query, (params || []) as any);
+    const result = await this._db.executeQuery(compiled);
+    return result.rows;
+  }
+
+  override async count(collection: string, query?: Record<string, unknown>): Promise<number> {
+    if (!this._db) throw new Error("DB not connected");
+    let qb = this._db.selectFrom(collection).select((eb) => eb.fn.count("id").as("count"));
+    if (query && Object.keys(query).length > 0) {
+      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+    }
+    const result = await qb.executeTakeFirst();
+    return Number(result?.count || 0);
+  }
+
+  override async create<T extends object>(collection: string, data: Partial<T>): Promise<T> {
+    if (!this._db) throw new Error("DB not connected");
+    return this._db.transaction().execute(async (tx) => {
+      const colDef = this._collections.find((c) => c.slug === collection);
+      const jsonFields =
+        colDef?.fields
+          .filter((f) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized))
+          .map((f) => f.name!) || [];
+      const flatData = flattenPayload(data, "", jsonFields);
+      const hasManyData: Record<string, unknown[]> = {};
+      const blocksData: Record<string, unknown[]> = {};
+
+      for (const key in flatData) {
+        if (Array.isArray(flatData[key])) {
+          const isHasMany = colDef?.fields.some(
+            (f) => f.type === "relationship" && "hasMany" in f && f.hasMany && f.name === key,
+          );
+
+          if (isHasMany) {
+            hasManyData[key] = flatData[key];
+          } else {
+            blocksData[key] = flatData[key];
+          }
+          delete flatData[key];
+        }
+      }
+
+      if (!flatData.id) flatData.id = crypto.randomUUID();
+
+      const ts = colDef?.timestamps !== false;
+      if (ts) {
+        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
+        const createdField = toSnakeCase(config.createdAt || "createdAt");
+        const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+        if (!flatData[createdField]) flatData[createdField] = new Date().toISOString();
+        if (!flatData[updatedField]) flatData[updatedField] = new Date().toISOString();
+      }
+
+      await tx.insertInto(collection).values(flatData).execute();
+
+      // hasMany relations
+      for (const [key, values] of Object.entries(hasManyData)) {
+        const joinTableName = `${collection}_${toSnakeCase(key)}_relations`.toLowerCase();
+        if (values.length > 0) {
+          const joinData = values.map((val: any, idx: number) => {
+            const tId = typeof val === "object" ? val.id : val;
+            return { id: crypto.randomUUID(), source_id: flatData.id, target_id: tId, order: idx };
+          });
+          await tx.insertInto(joinTableName).values(joinData).execute();
+        }
+      }
+
+      // Blocks
+      for (const [key, blocks] of Object.entries(blocksData)) {
+        for (let i = 0; i < (blocks as any[]).length; i++) {
+          const block = blocks[i] as any;
+          if (!block.blockType) continue;
+          const blockTableName =
+            `${collection}_${toSnakeCase(key)}_${block.blockType}`.toLowerCase();
+          const bId = block.id || crypto.randomUUID();
+          const blockFlatData = flattenPayload({ ...block, id: bId });
+          delete blockFlatData.blockType;
+          await tx
+            .insertInto(blockTableName)
+            .values({
+              ...blockFlatData,
+              _parent_id: flatData.id,
+              _order: i,
+              block_type: block.blockType,
+            })
+            .execute();
+        }
+      }
+
+      return this.findOne<T>(collection, { id: flatData.id }, tx) as Promise<T>;
+    });
+  }
+
+  override async findOne<T extends object>(
+    collection: string,
+    query: Record<string, unknown>,
+    tx?: any,
+  ): Promise<T | null> {
+    const executor = tx || this._db;
+    if (!executor) throw new Error("DB not connected");
+    let qb = executor.selectFrom(collection).selectAll();
+    if (query && Object.keys(query).length > 0) {
+      qb = qb.where((eb: any) => buildKyselyWhere(eb, query) || eb.val(true));
+    }
+
+    const row = await qb.executeTakeFirst();
+    if (!row) return null;
+
+    const unflattened = unflattenRow(row);
+    const colDef = this._collections.find((c) => c.slug === collection);
+
+    if (colDef) {
+      const { getRelationalFields, toSnakeCase } = await import("./kysely/field-mapper.js");
+      const relationalFields = getRelationalFields(colDef.fields);
+
+      for (const field of relationalFields) {
+        if (!field.name) continue;
+        const snakeName = toSnakeCase(field.name);
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+          const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
+          try {
+            const relations = await executor
+              .selectFrom(joinTableName)
+              .selectAll()
+              .where("source_id", "=", row.id)
+              .orderBy("order", "asc")
+              .execute();
+            const parts = field.name!.split("__");
+            let current = unflattened;
+            for (let i = 0; i < parts.length - 1; i++) {
+              if (!current[parts[i]!]) current[parts[i]!] = {};
+              current = current[parts[i]!];
+            }
+            current[parts[parts.length - 1]!] = relations.map((r: any) => r.target_id);
+          } catch (e) {}
+        } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
+          const blockData: any[] = [];
+          for (const b of field.blocks) {
+            const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
+            try {
+              const blocks = await executor
+                .selectFrom(blockTableName)
+                .selectAll()
+                .where("_parent_id", "=", row.id)
+                .execute();
+
+              for (const blk of blocks) {
+                const uf = unflattenRow(blk);
+                uf.blockType = blk.block_type;
+                blockData.push(uf);
+              }
+            } catch (e) {}
+          }
+          blockData.sort((a, b) => a._order - b._order);
+          blockData.forEach((b) => {
+            delete b._order;
+            delete b._parent_id;
+          });
+          const parts = field.name!.split("__");
+          let current = unflattened;
+          for (let i = 0; i < parts.length - 1; i++) {
+            if (!current[parts[i]!]) current[parts[i]!] = {};
+            current = current[parts[i]!];
+          }
+          current[parts[parts.length - 1]!] = blockData;
+        }
+      }
+    }
+
+    return unflattened as T;
+  }
+
+  override async find<T extends object>(
+    collection: string,
+    query?: Record<string, unknown>,
+    options?: FindOptions,
+  ): Promise<PaginatedResult<T>> {
+    if (!this._db) throw new Error("DB not connected");
+    const page = options?.page || 1;
+    const limit = options?.limit || 10;
+    const offset = (page - 1) * limit;
+
+    const total = await this.count(collection, query);
+
+    let qb = this._db.selectFrom(collection).selectAll().limit(limit).offset(offset);
+    if (query && Object.keys(query).length > 0) {
+      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+    }
+    if (options?.sort) {
+      const [col, dir] = (options.sort ?? "").split(":");
+      if (col) {
+        qb = qb.orderBy(col as any, dir === "desc" ? "desc" : "asc");
+      }
+    } else {
+      qb = qb.orderBy("created_at" as any, "desc");
+    }
+
+    const rows = await qb.execute();
+
+    const docs = await Promise.all(rows.map((row) => this.findOne<T>(collection, { id: row.id })));
+
+    const totalPages = Math.ceil(total / limit);
+    return {
+      docs: docs.filter(Boolean) as T[],
+      totalDocs: total,
+      limit,
+      totalPages,
+      page,
+      pagingCounter: offset + 1,
+      hasNextPage: page * limit < total,
+      hasPrevPage: page > 1,
+      prevPage: page > 1 ? page - 1 : null,
+      nextPage: page < totalPages ? page + 1 : null,
+    };
+  }
+
+  override async update<T extends object>(
+    collection: string,
+    query: Record<string, unknown> | string | number,
+    data: Partial<T>,
+  ): Promise<T> {
+    if (!this._db) throw new Error("DB not connected");
+    return this._db.transaction().execute(async (tx) => {
+      let normalizedQuery = query;
+      if (typeof query !== "object" || query === null) {
+        normalizedQuery = { id: query };
+      }
+
+      const current = await this.findOne<any>(
+        collection,
+        normalizedQuery as Record<string, unknown>,
+        tx,
+      );
+      if (!current) throw new Error("Document not found");
+
+      const colDef = this._collections.find((c) => c.slug === collection);
+      const jsonFields =
+        colDef?.fields
+          .filter((f) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized))
+          .map((f) => f.name!) || [];
+      const flatData = flattenPayload(data, "", jsonFields);
+      const hasManyData: Record<string, unknown[]> = {};
+      const blocksData: Record<string, unknown[]> = {};
+
+      for (const key in flatData) {
+        if (Array.isArray(flatData[key])) {
+          const isHasMany = colDef?.fields.some(
+            (f) => f.type === "relationship" && "hasMany" in f && f.hasMany && f.name === key,
+          );
+          if (isHasMany) {
+            hasManyData[key] = flatData[key];
+          } else {
+            blocksData[key] = flatData[key];
+          }
+          delete flatData[key];
+        }
+      }
+
+      const ts = colDef?.timestamps !== false;
+      if (ts) {
+        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
+        const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+        flatData[updatedField] = new Date().toISOString();
+      }
+
+      if (Object.keys(flatData).length > 0) {
+        await tx.updateTable(collection).set(flatData).where("id", "=", current.id).execute();
+      }
+
+      for (const [key, values] of Object.entries(hasManyData)) {
+        const joinTableName = `${collection}_${toSnakeCase(key)}_relations`.toLowerCase();
+        await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+        if (values.length > 0) {
+          const joinData = values.map((val: any, idx: number) => {
+            const tId = typeof val === "object" ? val.id : val;
+            return { id: crypto.randomUUID(), source_id: current.id, target_id: tId, order: idx };
+          });
+          await tx.insertInto(joinTableName).values(joinData).execute();
+        }
+      }
+
+      for (const [key, blocks] of Object.entries(blocksData)) {
+        const fieldDef = colDef?.fields.find((f) => f.name === key);
+        if (fieldDef && "blocks" in fieldDef && fieldDef.blocks) {
+          for (const b of fieldDef.blocks) {
+            const blockTableName = `${collection}_${toSnakeCase(key)}_${b.slug}`.toLowerCase();
+            try {
+              await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+            } catch (e) {}
+          }
+        }
+
+        for (let i = 0; i < (blocks as any[]).length; i++) {
+          const block = blocks[i] as any;
+          if (!block.blockType) continue;
+          const blockTableName =
+            `${collection}_${toSnakeCase(key)}_${block.blockType}`.toLowerCase();
+          const bId = block.id || crypto.randomUUID();
+          const blockFlatData = flattenPayload({ ...block, id: bId });
+          delete blockFlatData.blockType;
+          await tx
+            .insertInto(blockTableName)
+            .values({
+              ...blockFlatData,
+              _parent_id: current.id,
+              _order: i,
+              block_type: block.blockType,
+            })
+            .execute();
+        }
+      }
+
+      return this.findOne<T>(collection, { id: current.id }, tx) as Promise<T>;
+    });
+  }
+
+  override async updateMany<T extends object>(
+    collection: string,
+    query: Record<string, unknown>,
+    data: Partial<T>,
+  ): Promise<number> {
+    if (!this._db) throw new Error("DB not connected");
+    return this._db.transaction().execute(async (tx) => {
+      let qb = tx.updateTable(collection);
+      if (query && Object.keys(query).length > 0) {
+        qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+      }
+
+      const flatData = flattenPayload(data);
+      for (const key in flatData) {
+        if (Array.isArray(flatData[key])) {
+          delete flatData[key];
+        }
+      }
+
+      const colDef = this._collections.find((c) => c.slug === collection);
+
+      const ts = colDef?.timestamps !== false;
+      if (ts) {
+        const config = typeof colDef?.timestamps === "object" ? colDef.timestamps : {};
+        const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+        flatData[updatedField] = new Date().toISOString();
+      }
+
+      if (Object.keys(flatData).length > 0) {
+        const result = await qb.set(flatData).executeTakeFirst();
+        return Number(result.numUpdatedRows || 0);
+      }
+      return 0;
+    });
+  }
+
+  override async delete(
+    collection: string,
+    query: Record<string, unknown> | string | number,
+  ): Promise<boolean> {
+    if (!this._db) throw new Error("DB not connected");
+    let normalizedQuery = query;
+    if (typeof query !== "object" || query === null) {
+      normalizedQuery = { id: query };
+    }
+
+    const current = await this.findOne<any>(collection, normalizedQuery as Record<string, unknown>);
+    if (!current) return false;
+
+    await this._db.transaction().execute(async (tx) => {
+      const colDef = this._collections.find((c) => c.slug === collection);
+      if (colDef) {
+        for (const field of colDef.fields) {
+          const snakeName = toSnakeCase(field.name!);
+          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+            const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
+            try {
+              await tx.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+            } catch (e) {}
+          } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
+            for (const b of field.blocks) {
+              const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
+              try {
+                await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+              } catch (e) {}
+            }
+          }
+        }
+      }
+      await tx.deleteFrom(collection).where("id", "=", current.id).execute();
+    });
+
+    return true;
+  }
+
+  override async deleteMany(collection: string, query: Record<string, unknown>): Promise<number> {
+    if (!this._db) throw new Error("DB not connected");
+    return this._db.transaction().execute(async (tx) => {
+      let selectQb = tx.selectFrom(collection).select("id");
+      if (query && Object.keys(query).length > 0) {
+        selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+      }
+      const docs = await selectQb.execute();
+      if (docs.length === 0) return 0;
+
+      const ids = docs.map((d) => d.id as string);
+      const colDef = this._collections.find((c) => c.slug === collection);
+
+      if (colDef) {
+        for (const field of colDef.fields) {
+          const snakeName = toSnakeCase(field.name!);
+          if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+            const joinTableName = `${collection}_${snakeName}_relations`.toLowerCase();
+            try {
+              await tx.deleteFrom(joinTableName).where("source_id", "in", ids).execute();
+            } catch (e) {}
+          } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
+            for (const b of field.blocks) {
+              const blockTableName = `${collection}_${snakeName}_${b.slug}`.toLowerCase();
+              try {
+                await tx.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
+              } catch (e) {}
+            }
+          }
+        }
+      }
+
+      const result = await tx.deleteFrom(collection).where("id", "in", ids).executeTakeFirst();
+      return Number(result.numDeletedRows || 0);
+    });
+  }
+
+  override async findGlobal<T extends object>(slug: string): Promise<T | null> {
+    if (!this._db) throw new Error("DB not connected");
+    const row = await this._db
+      .selectFrom(slug as any)
+      .selectAll()
+      .limit(1)
+      .executeTakeFirst();
+    return row ? (unflattenRow(row) as T) : null;
+  }
+
+  override async updateGlobal<T extends object>(slug: string, data: Partial<T>): Promise<T> {
+    if (!this._db) throw new Error("DB not connected");
+    const existing = await this.findGlobal<any>(slug);
+    const globalDef = this._globals.find((g) => g.slug === slug);
+    const jsonFields =
+      globalDef?.fields
+        .filter((f) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized))
+        .map((f) => f.name!) || [];
+    const flatData = flattenPayload(data, "", jsonFields);
+    const ts = globalDef?.timestamps !== false;
+    if (ts) {
+      const config = typeof globalDef?.timestamps === "object" ? globalDef.timestamps : {};
+      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+      flatData[updatedField] = new Date().toISOString();
+    }
+
+    if (!existing) {
+      if (!flatData.id) flatData.id = "global";
+      if (ts) {
+        const config = typeof globalDef?.timestamps === "object" ? globalDef.timestamps : {};
+        const createdField = toSnakeCase(config.createdAt || "createdAt");
+        if (!flatData[createdField]) flatData[createdField] = new Date().toISOString();
+      }
+      await this._db
+        .insertInto(slug as any)
+        .values(flatData)
+        .execute();
+    } else {
+      await this._db
+        .updateTable(slug as any)
+        .set(flatData)
+        .where("id", "=", existing.id)
+        .execute();
+    }
+    return this.findGlobal<T>(slug) as Promise<T>;
+  }
+
+  override async runMigrations(): Promise<void> {
+    if (!this._db) throw new Error("DB not connected");
+
+    const migrator = new Migrator({
+      db: this._db,
+      provider: new FileMigrationProvider({
+        fs,
+        path,
+        migrationFolder: path.resolve(process.cwd(), this.migrationDir),
+      }),
+    });
+
+    const { error, results } = await migrator.migrateToLatest();
+
+    results?.forEach((it) => {
+      if (it.status === "Success") {
+        logger.success(`🚀 Migration "${it.migrationName}" was executed successfully`);
+      } else if (it.status === "Error") {
+        logger.error(`❌ Migration "${it.migrationName}" failed`);
+      }
+    });
+
+    if (error) {
+      throw error;
+    }
+  }
+
+  override async migrate(collections: Collection[], globals: Global[] = []): Promise<void> {
+    const { getSystemCollections } = await import("./system-schema");
+    this._collections = [...getSystemCollections(), ...collections];
+    this._globals = globals;
+    if (this.push && this._db) {
+      await pushSchema(this._db, "postgres", collections, globals, {
+        pushDestructive: this.pushDestructive,
+      });
+    }
+  }
+}
+
+export function createPostgresAdapter(
+  config: PostgresConfig | string,
+  options?: { push?: boolean; pushDestructive?: boolean; migrationDir?: string },
+): PostgresAdapter {
+  return new PostgresAdapter(config, options);
+}