opacacms 0.3.16 → 0.3.17

package/dist/db/d1.js

@@ -1,14 +1,610 @@
 import {
-  D1Adapter,
-  createD1Adapter
-} from "../chunk-5b9eqr34.js";
-import"../chunk-re459gm9.js";
-import"../chunk-s8mqwnm1.js";
-import"../chunk-q5sb5dcr.js";
-import"../chunk-5xpf5jxd.js";
-import"../chunk-jq1drsen.js";
+  buildKyselyWhere,
+  flattenPayload,
+  pushSchema,
+  unflattenRow
+} from "../chunk-re459gm9.js";
+import {
+  requestContext
+} from "../chunk-q5sb5dcr.js";
+import {
+  flattenFields,
+  getRelationalFields,
+  toSnakeCase
+} from "../chunk-5xpf5jxd.js";
+import {
+  logger
+} from "../chunk-jq1drsen.js";
 import"../chunk-h8v093av.js";
-import"../chunk-8sqjbsgt.js";
+import {
+  BaseDatabaseAdapter
+} from "../chunk-s8mqwnm1.js";
+import {
+  __require
+} from "../chunk-8sqjbsgt.js";
+
+// src/db/d1.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { CompiledQuery, FileMigrationProvider, Migrator } from "kysely";
+class D1Adapter extends BaseDatabaseAdapter {
+  name = "d1";
+  _rawDb;
+  _db = null;
+  _collections = [];
+  _globals = [];
+  push;
+  migrationDir;
+  pushDestructive;
+  get raw() {
+    return this._rawDb;
+  }
+  get db() {
+    if (!this._db)
+      throw new Error("Database not connected. Call connect() first.");
+    return this._db;
+  }
+  constructor(db, options) {
+    super();
+    this._rawDb = db;
+    const isDev = typeof process !== "undefined" && true;
+    this.push = options?.push ?? isDev;
+    this.pushDestructive = options?.pushDestructive ?? false;
+    this.migrationDir = options?.migrationDir ?? "./migrations";
+  }
+  async connect() {
+    if (this._db)
+      return;
+    const { D1Dialect } = await import("kysely-d1");
+    const { createOpacaKysely } = await import("../chunk-gzbz5jwy.js");
+    this._db = createOpacaKysely({
+      dialect: new D1Dialect({ database: this._rawDb }),
+      config: {
+        collections: this._collections,
+        globals: this._globals,
+        db: { name: "d1" }
+      }
+    });
+  }
+  async disconnect() {
+    if (this._db)
+      await this.db.destroy();
+  }
+  async unsafe(query, params) {
+    const compiled = CompiledQuery.raw(query, params || []);
+    const result = await this.db.executeQuery(compiled);
+    return result.rows;
+  }
+  async count(collection, query) {
+    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);
+  }
+  async create(collection, data) {
+    const tableName = toSnakeCase(collection);
+    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 relationalFields = getRelationalFields(colDef?.fields || []);
+    const hasManyData = {};
+    const blocksData = {};
+    for (const field of relationalFields) {
+      const key = field.name;
+      if (Array.isArray(flatData[key])) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+          hasManyData[key] = flatData[key];
+        } else if (field.type === "blocks") {
+          blocksData[key] = flatData[key];
+        }
+        delete flatData[key];
+      }
+    }
+    if (!flatData.id)
+      flatData.id = crypto.randomUUID();
+    const dbFields = flattenFields(colDef?.fields || []);
+    const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
+    validCols.add("id");
+    validCols.add(toSnakeCase("createdAt"));
+    validCols.add(toSnakeCase("updatedAt"));
+    const filteredData = {};
+    for (const col of Object.keys(flatData)) {
+      if (validCols.has(col)) {
+        filteredData[col] = flatData[col];
+      }
+    }
+    try {
+      await this.db.insertInto(tableName).values(filteredData).execute();
+    } catch (e) {
+      logger.error(`[D1] Create failed in ${collection}: ${e.message}`);
+      throw e;
+    }
+    for (const [key, values] of Object.entries(hasManyData)) {
+      const joinTableName = `${tableName}_${toSnakeCase(key)}_relations`.toLowerCase();
+      if (values.length > 0) {
+        const joinData = values.map((val, idx) => {
+          const tId = typeof val === "object" ? val.id : val;
+          return { id: crypto.randomUUID(), source_id: flatData.id, target_id: tId, order: idx };
+        });
+        await this.db.insertInto(joinTableName).values(joinData).execute();
+      }
+    }
+    for (const [key, blocks] of Object.entries(blocksData)) {
+      for (let i = 0;i < blocks.length; i++) {
+        const block = blocks[i];
+        if (!block.blockType)
+          continue;
+        const blockTableName = `${tableName}_${toSnakeCase(key)}_${toSnakeCase(block.blockType)}`.toLowerCase();
+        const bId = block.id || crypto.randomUUID();
+        const blockDef = relationalFields.find((f) => f.name === key && f.type === "blocks");
+        const blockConfig = blockDef?.blocks?.find((b) => b.slug === block.blockType);
+        const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => toSnakeCase(f.name)) || [];
+        const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
+        for (const f of blockJsonFields) {
+          if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
+            blockFlatData[f] = JSON.stringify(blockFlatData[f]);
+          }
+        }
+        delete blockFlatData.blockType;
+        const blockData = {
+          ...blockFlatData,
+          _parent_id: flatData.id,
+          _order: i,
+          block_type: block.blockType
+        };
+        await this.db.insertInto(blockTableName).values(blockData).execute();
+      }
+    }
+    return this.findOne(collection, { id: flatData.id }, this.db);
+  }
+  async findOne(collection, query, tx) {
+    const tableName = toSnakeCase(collection);
+    const executor = tx || this.db;
+    let qb = executor.selectFrom(tableName).selectAll();
+    if (query && Object.keys(query).length > 0) {
+      qb = qb.where((eb) => 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 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 = `${tableName}_${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) => r.target_id);
+          } catch (e) {}
+        } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
+          const blockData = [];
+          for (const b of field.blocks) {
+            const blockTableName = `${tableName}_${snakeName}_${toSnakeCase(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;
+  }
+  async find(collection, query, options) {
+    const page = options?.page || 1;
+    const limit = options?.limit || 10;
+    const offset = (page - 1) * limit;
+    const cursorColumn = options?.cursorColumn || "id";
+    const total = await this.count(collection, query);
+    const tableName = toSnakeCase(collection);
+    let qb = this.db.selectFrom(tableName).selectAll().limit(limit);
+    if (options?.after) {
+      qb = qb.where(cursorColumn, ">", options.after);
+    } else if (options?.before) {
+      qb = qb.where(cursorColumn, "<", options.before);
+    } else {
+      qb = qb.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, dir === "desc" ? "desc" : "asc");
+      }
+    } else {
+      qb = qb.orderBy(cursorColumn, "desc");
+    }
+    const rows = await qb.execute();
+    if (rows.length === 0) {
+      const totalPages2 = Math.ceil(total / limit);
+      const afterAnchor = options?.after;
+      const beforeAnchor = options?.before;
+      return {
+        docs: [],
+        totalDocs: total,
+        limit,
+        totalPages: totalPages2,
+        page,
+        pagingCounter: offset + 1,
+        hasNextPage: false,
+        hasPrevPage: !!afterAnchor || page > 1,
+        prevPage: null,
+        nextPage: null,
+        nextCursor: null,
+        prevCursor: afterAnchor ? afterAnchor : null
+      };
+    }
+    const rowIds = rows.map((r) => r.id);
+    const docs = rows.map((r) => unflattenRow(r));
+    const colDef = this._collections.find((c) => c.slug === collection);
+    if (colDef) {
+      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 = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
+          try {
+            const allRelations = await this.db.selectFrom(joinTableName).selectAll().where("source_id", "in", rowIds).orderBy("order", "asc").execute();
+            const relationsBySource = allRelations.reduce((acc, r) => {
+              if (!acc[r.source_id])
+                acc[r.source_id] = [];
+              acc[r.source_id].push(r.target_id);
+              return acc;
+            }, {});
+            const parts = field.name.split("__");
+            for (let docIdx = 0;docIdx < docs.length; docIdx++) {
+              const rowId = rowIds[docIdx];
+              let current = docs[docIdx];
+              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]] = relationsBySource[rowId] || [];
+            }
+          } catch (e) {}
+        } else if (field.type === "blocks" && field.blocks) {
+          const blocksBySource = {};
+          for (const b of field.blocks) {
+            const blockTableName = `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
+            try {
+              const allBlocks = await this.db.selectFrom(blockTableName).selectAll().where("_parent_id", "in", rowIds).execute();
+              for (const blk of allBlocks) {
+                const uf = unflattenRow(blk);
+                uf.blockType = blk.block_type;
+                if (!blocksBySource[blk._parent_id])
+                  blocksBySource[blk._parent_id] = [];
+                blocksBySource[blk._parent_id].push(uf);
+              }
+            } catch (e) {}
+          }
+          const parts = field.name.split("__");
+          for (let docIdx = 0;docIdx < docs.length; docIdx++) {
+            const rowId = rowIds[docIdx];
+            const blockData = blocksBySource[rowId] || [];
+            blockData.sort((a, b) => a._order - b._order);
+            blockData.forEach((b) => {
+              delete b._order;
+              delete b._parentId;
+            });
+            let current = docs[docIdx];
+            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;
+          }
+        }
+      }
+    }
+    const totalPages = Math.ceil(total / limit);
+    const hasNextPage = page * limit < total;
+    return {
+      docs: docs.filter(Boolean),
+      totalDocs: total,
+      limit,
+      totalPages,
+      page,
+      pagingCounter: offset + 1,
+      hasNextPage,
+      hasPrevPage: page > 1 || !!options?.after || !!options?.before,
+      prevPage: page > 1 ? page - 1 : null,
+      nextPage: page < totalPages ? page + 1 : null,
+      nextCursor: docs.length > 0 && hasNextPage ? docs[docs.length - 1][cursorColumn] : null,
+      prevCursor: docs.length > 0 && (page > 1 || !!options?.after || !!options?.before) ? docs[0][cursorColumn] : null
+    };
+  }
+  async update(collection, query, data) {
+    const tableName = toSnakeCase(collection);
+    let normalizedQuery = query;
+    if (typeof query !== "object" || query === null) {
+      normalizedQuery = { id: query };
+    }
+    const current = await this.findOne(collection, normalizedQuery, this.db);
+    if (!current)
+      throw new Error("Document not found");
+    const store = requestContext.getStore();
+    if (store)
+      store.previousData = current;
+    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 relationalFields = getRelationalFields(colDef?.fields || []);
+    const hasManyData = {};
+    const blocksData = {};
+    for (const field of relationalFields) {
+      const key = field.name;
+      if (Array.isArray(flatData[key])) {
+        if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+          hasManyData[key] = flatData[key];
+        } else if (field.type === "blocks") {
+          blocksData[key] = flatData[key];
+        }
+        delete flatData[key];
+      }
+    }
+    if (Object.keys(flatData).length > 0) {
+      const dbFields = flattenFields(colDef?.fields || []);
+      const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
+      validCols.add("id");
+      const filteredData = {};
+      for (const col of Object.keys(flatData)) {
+        if (validCols.has(col)) {
+          filteredData[col] = flatData[col];
+        }
+      }
+      try {
+        await this.db.updateTable(tableName).set(filteredData).where("id", "=", current.id).execute();
+      } catch (e) {
+        logger.error(`[D1] Update failed in ${collection}: ${e.message}`);
+        throw e;
+      }
+    }
+    for (const [key, values] of Object.entries(hasManyData)) {
+      const joinTableName = `${tableName}_${toSnakeCase(key)}_relations`.toLowerCase();
+      await this.db.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+      if (values.length > 0) {
+        const joinData = values.map((val, idx) => {
+          const tId = typeof val === "object" ? val.id : val;
+          return { id: crypto.randomUUID(), source_id: current.id, target_id: tId, order: idx };
+        });
+        await this.db.insertInto(joinTableName).values(joinData).execute();
+      }
+    }
+    for (const [key, blocks] of Object.entries(blocksData)) {
+      const blockDef = relationalFields.find((f) => f.name === key && f.type === "blocks");
+      if (blockDef && "blocks" in blockDef && blockDef.blocks) {
+        await Promise.all(blockDef.blocks.map(async (b) => {
+          const blockTableName = `${tableName}_${toSnakeCase(key)}_${toSnakeCase(b.slug)}`.toLowerCase();
+          try {
+            await this.db.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+          } catch (e) {}
+        }));
+      }
+      for (let i = 0;i < blocks.length; i++) {
+        const block = blocks[i];
+        if (!block.blockType)
+          continue;
+        const blockTableName = `${tableName}_${toSnakeCase(key)}_${toSnakeCase(block.blockType)}`.toLowerCase();
+        const bId = block.id || crypto.randomUUID();
+        const blockConfig = blockDef?.blocks?.find((b) => b.slug === block.blockType);
+        const blockJsonFields = blockConfig?.fields.filter((f) => ["richtext", "json", "file"].includes(f.type)).map((f) => toSnakeCase(f.name)) || [];
+        const blockFlatData = flattenPayload({ ...block, id: bId }, "", blockJsonFields);
+        for (const f of blockJsonFields) {
+          if (blockFlatData[f] && typeof blockFlatData[f] === "object") {
+            blockFlatData[f] = JSON.stringify(blockFlatData[f]);
+          }
+        }
+        delete blockFlatData.blockType;
+        const blockData = {
+          ...blockFlatData,
+          _parent_id: current.id,
+          _order: i,
+          block_type: block.blockType
+        };
+        await this.db.insertInto(blockTableName).values(blockData).execute();
+      }
+    }
+    return this.findOne(collection, { id: current.id }, this.db);
+  }
+  async updateMany(collection, query, data) {
+    const tableName = toSnakeCase(collection);
+    let qb = this.db.updateTable(tableName);
+    if (query && Object.keys(query).length > 0) {
+      qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+    }
+    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);
+    for (const key in flatData) {
+      if (Array.isArray(flatData[key])) {
+        delete flatData[key];
+      }
+    }
+    if (Object.keys(flatData).length > 0) {
+      const dbFields = flattenFields(colDef?.fields || []);
+      const validCols = new Set(dbFields.map((f) => toSnakeCase(f.name)));
+      validCols.add("id");
+      const filteredData = {};
+      for (const col of Object.keys(flatData)) {
+        if (validCols.has(col)) {
+          filteredData[col] = flatData[col];
+        }
+      }
+      logger.debug(`[D1] Bulk updating in ${collection}...`);
+      try {
+        const result = await qb.set(filteredData).executeTakeFirst();
+        return Number(result.numUpdatedRows || 0);
+      } catch (e) {
+        logger.error(`[D1] Bulk update failed in ${collection}: ${e.message}`);
+        throw e;
+      }
+    }
+    return 0;
+  }
+  async delete(collection, query) {
+    const tableName = toSnakeCase(collection);
+    let normalizedQuery = query;
+    if (typeof query !== "object" || query === null) {
+      normalizedQuery = { id: query };
+    }
+    const current = await this.findOne(collection, normalizedQuery);
+    if (!current)
+      return false;
+    const colDef = this._collections.find((c) => c.slug === collection);
+    if (colDef) {
+      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 = `${tableName}_${snakeName}_relations`.toLowerCase();
+          try {
+            await this.db.deleteFrom(joinTableName).where("source_id", "=", current.id).execute();
+          } catch (e) {}
+        } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
+          await Promise.all(field.blocks.map(async (b) => {
+            const blockTableName = `${tableName}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
+            try {
+              await this.db.deleteFrom(blockTableName).where("_parent_id", "=", current.id).execute();
+            } catch (e) {}
+          }));
+        }
+      }
+    }
+    await this.db.deleteFrom(tableName).where("id", "=", current.id).execute();
+    return true;
+  }
+  async deleteMany(collection, query) {
+    const tableName = toSnakeCase(collection);
+    let selectQb = this.db.selectFrom(tableName).select("id");
+    if (query && Object.keys(query).length > 0) {
+      selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
+    }
+    const rowsToDelete = await selectQb.execute();
+    const idsToDelete = rowsToDelete.map((row) => row.id);
+    if (idsToDelete.length === 0)
+      return 0;
+    const colDef = this._collections.find((c) => c.slug === collection);
+    if (colDef) {
+      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 = `${tableName}_${snakeName}_relations`.toLowerCase();
+          try {
+            await this.db.deleteFrom(joinTableName).where("source_id", "in", idsToDelete).execute();
+          } catch (e) {}
+        } else if (field.type === "blocks" && "blocks" in field && field.blocks) {
+          await Promise.all(field.blocks.map(async (b) => {
+            const blockTableName = `${tableName}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
+            try {
+              await this.db.deleteFrom(blockTableName).where("_parent_id", "in", idsToDelete).execute();
+            } catch (e) {}
+          }));
+        }
+      }
+    }
+    const result = await this.db.deleteFrom(tableName).where("id", "in", idsToDelete).executeTakeFirst();
+    return Number(result.numDeletedRows || 0);
+  }
+  async findGlobal(slug) {
+    const tableName = toSnakeCase(slug);
+    const row = await this.db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
+    return row ? unflattenRow(row) : null;
+  }
+  async updateGlobal(slug, data) {
+    const tableName = toSnakeCase(slug);
+    const existing = await this.findGlobal(slug);
+    const flatData = flattenPayload(data);
+    const globalDef = this._globals.find((g) => g.slug === slug);
+    const now = new Date().toISOString();
+    flatData[toSnakeCase("updatedAt")] = now;
+    if (!existing) {
+      if (!flatData.id)
+        flatData.id = "global";
+      flatData[toSnakeCase("createdAt")] = now;
+      await this.db.insertInto(tableName).values(flatData).execute();
+    } else {
+      await this.db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
+    }
+    return this.findGlobal(slug);
+  }
+  async runMigrations() {
+    const migrator = new Migrator({
+      db: this.db,
+      provider: new FileMigrationProvider({
+        fs,
+        path,
+        migrationFolder: pathToFileURL(path.resolve(process.cwd(), this.migrationDir)).href
+      })
+    });
+    const { error, results } = await migrator.migrateToLatest();
+    results?.forEach((it) => {
+      if (it.status === "Success") {
+        logger.success(`\uD83D\uDE80 Migration "${it.migrationName}" was executed successfully`);
+      } else if (it.status === "Error") {
+        logger.error(`❌ Migration "${it.migrationName}" failed`);
+      }
+    });
+    if (error) {
+      throw error;
+    }
+  }
+  async migrate(collections, globals = []) {
+    this._collections = collections;
+    this._globals = globals;
+    if (this.push) {
+      await pushSchema(this.db, "d1", collections, globals, {
+        pushDestructive: this.pushDestructive
+      });
+    }
+  }
+}
+function createD1Adapter(db, options) {
+  return new D1Adapter(db, options);
+}
 export {
   createD1Adapter,
   D1Adapter

package/dist/db/index.d.ts

@@ -2,8 +2,3 @@ import type { Kysely } from "kysely";
 export { sql } from "kysely";
 export type OpacaMigrationDb = Kysely<any>;
 export * from "./adapter";
-export * from "./better-sqlite";
-export * from "./bun-sqlite";
-export * from "./d1";
-export * from "./postgres";
-export * from "./sqlite";

package/dist/db/index.js

@@ -1,43 +1,8 @@
-import {
-  D1Adapter,
-  createD1Adapter
-} from "../chunk-5b9eqr34.js";
-import {
-  PostgresAdapter,
-  createPostgresAdapter
-} from "../chunk-tsmhn78f.js";
-import {
-  SQLiteAdapter,
-  createSQLiteAdapter
-} from "../chunk-nz6xhtja.js";
-import {
-  BunSQLiteAdapter,
-  createBunSQLiteAdapter
-} from "../chunk-qsefknd3.js";
-import {
-  BetterSQLiteAdapter,
-  createBetterSQLiteAdapter
-} from "../chunk-dz5bh1bd.js";
-import"../chunk-re459gm9.js";
 import {
   BaseDatabaseAdapter
 } from "../chunk-s8mqwnm1.js";
-import"../chunk-q5sb5dcr.js";
-import"../chunk-5xpf5jxd.js";
-import"../chunk-jq1drsen.js";
-import"../chunk-h8v093av.js";
 import"../chunk-8sqjbsgt.js";
 export {
   sql,
-  createSQLiteAdapter,
-  createPostgresAdapter,
-  createD1Adapter,
-  createBunSQLiteAdapter,
-  createBetterSQLiteAdapter,
-  SQLiteAdapter,
-  PostgresAdapter,
-  D1Adapter,
-  BunSQLiteAdapter,
-  BetterSQLiteAdapter,
   BaseDatabaseAdapter
 };