opacacms 0.1.12 → 0.1.13

package/src/db/postgres.ts

@@ -1,631 +0,0 @@
-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");
-    const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).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");
-    const tableName = toSnakeCase(collection);
-    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(tableName).values(flatData).execute();
-
-      // hasMany relations
-      for (const [key, values] of Object.entries(hasManyData)) {
-        const joinTableName = `${tableName}_${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 =
-            `${tableName}_${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 tableName = toSnakeCase(collection);
-    const executor = tx || this._db;
-    if (!executor) throw new Error("DB not connected");
-    let qb = executor.selectFrom(tableName).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);
-
-    const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).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();
-      }
-
-      const tableName = toSnakeCase(collection);
-      if (Object.keys(flatData).length > 0) {
-        await tx.updateTable(tableName).set(flatData).where("id", "=", current.id).execute();
-      }
-
-      for (const [key, values] of Object.entries(hasManyData)) {
-        const joinTableName = `${tableName}_${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 = `${tableName}_${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 =
-            `${tableName}_${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");
-    const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
-      let qb = tx.updateTable(tableName);
-      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;
-
-    const tableName = toSnakeCase(collection);
-    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 = `${tableName}_${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 = `${tableName}_${snakeName}_${b.slug}`.toLowerCase();
-              try {
-                await tx.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
-              } catch (e) { }
-            }
-          }
-        }
-      }
-      await tx.deleteFrom(tableName).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");
-    const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
-      let selectQb = tx.selectFrom(tableName).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 = `${tableName}_${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 = `${tableName}_${snakeName}_${b.slug}`.toLowerCase();
-              try {
-                await tx.deleteFrom(blockTableName).where("_parent_id", "in", ids).execute();
-              } catch (e) { }
-            }
-          }
-        }
-      }
-
-      const result = await tx.deleteFrom(tableName).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 tableName = toSnakeCase(slug);
-    const row = await this._db
-      .selectFrom(tableName 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 tableName = toSnakeCase(slug);
-    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(tableName as any)
-        .values(flatData)
-        .execute();
-    } else {
-      await this._db
-        .updateTable(tableName 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);
-}