@better-media/adapter-db 0.1.0

package/dist/index.js

@@ -0,0 +1,610 @@
+'use strict';
+
+var core = require('@better-media/core');
+var kysely = require('kysely');
+var mongodbAdapter = require('@better-media/mongodb-adapter');
+
+// src/adapters/memory/memory-db.adapter.ts
+var MemoryDbAdapter = class {
+  store = /* @__PURE__ */ new Map();
+  schema;
+  hooks;
+  constructor(options) {
+    this.schema = options?.schema;
+    this.hooks = options?.hooks;
+  }
+  getTable(model) {
+    let table = this.store.get(model);
+    if (!table) {
+      table = /* @__PURE__ */ new Map();
+      this.store.set(model, table);
+    }
+    return table;
+  }
+  getModelFields(model) {
+    return this.schema?.[model]?.fields ?? {};
+  }
+  getModelDefinition(model) {
+    return this.schema?.[model];
+  }
+  getHookContext(model, trx) {
+    return {
+      model,
+      adapter: this,
+      transaction: trx
+    };
+  }
+  matchCondition(record, condition) {
+    const recordValue = record[condition.field];
+    const targetValue = condition.value;
+    switch (condition.operator) {
+      case "!=":
+        return recordValue !== targetValue;
+      case "<":
+        return Number(recordValue) < Number(targetValue);
+      case "<=":
+        return Number(recordValue) <= Number(targetValue);
+      case ">":
+        return Number(recordValue) > Number(targetValue);
+      case ">=":
+        return Number(recordValue) >= Number(targetValue);
+      case "in":
+        return Array.isArray(targetValue) && targetValue.includes(recordValue);
+      case "not_in":
+        return Array.isArray(targetValue) && !targetValue.includes(recordValue);
+      case "contains":
+        return typeof recordValue === "string" && recordValue.includes(String(targetValue));
+      case "starts_with":
+        return String(recordValue).toLowerCase().startsWith(String(targetValue).toLowerCase());
+      case "ends_with":
+        return String(recordValue).toLowerCase().endsWith(String(targetValue).toLowerCase());
+      case "like":
+        return typeof recordValue === "string" && recordValue.toLowerCase().includes(String(targetValue).toLowerCase());
+      case "=":
+      default:
+        return recordValue === targetValue;
+    }
+  }
+  matchesWhere(record, where, model, options) {
+    const definition = model ? this.getModelDefinition(model) : void 0;
+    if (definition?.softDelete && !options?.withDeleted) {
+      if (record.deletedAt !== null && record.deletedAt !== void 0) return false;
+    }
+    if (!where || where.length === 0) return true;
+    let isMatch = true;
+    for (let i = 0; i < where.length; i++) {
+      const condition = where[i];
+      const connector = i > 0 ? where[i - 1]?.connector ?? "AND" : "AND";
+      const conditionMatches = this.matchCondition(record, condition);
+      if (connector === "OR") {
+        isMatch = isMatch || conditionMatches;
+      } else {
+        isMatch = isMatch && conditionMatches;
+      }
+    }
+    return isMatch;
+  }
+  async create(options) {
+    const table = this.getTable(options.model);
+    const fields = this.getModelFields(options.model);
+    const context = this.getHookContext(options.model);
+    let dataToInsert = options.data;
+    dataToInsert = await core.runHooks.beforeCreate(this.hooks, dataToInsert, context);
+    if (!dataToInsert.id) {
+      throw new Error("MemoryDbAdapter requires 'id' in data for create operations");
+    }
+    const serializedData = core.serializeData(fields, dataToInsert);
+    const clonedData = JSON.parse(JSON.stringify(serializedData));
+    table.set(String(clonedData.id), clonedData);
+    const resultRecord = core.deserializeData(fields, clonedData);
+    await core.runHooks.afterCreate(this.hooks, resultRecord, context);
+    return resultRecord;
+  }
+  populateRecord(record, model, populate) {
+    const result = JSON.parse(JSON.stringify(record));
+    const sortedPopulate = [...populate].sort((a, b) => a.split(".").length - b.split(".").length);
+    for (const path of sortedPopulate) {
+      const parts = path.split(".");
+      let currentObj = result;
+      let currentModel = model;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const fieldDef = this.schema?.[currentModel]?.fields[part];
+        if (fieldDef?.references) {
+          const relatedTable = this.getTable(fieldDef.references.model);
+          const localValue = currentObj[part];
+          if (localValue === void 0 || localValue === null) break;
+          const relatedId = typeof localValue === "object" ? localValue.id : localValue;
+          const relatedRecord = relatedTable.get(String(relatedId));
+          if (relatedRecord) {
+            currentObj[part] = JSON.parse(JSON.stringify(relatedRecord));
+            currentModel = fieldDef.references.model;
+            currentObj = currentObj[part];
+          } else {
+            break;
+          }
+        } else {
+          break;
+        }
+      }
+    }
+    return result;
+  }
+  async findOne(options) {
+    const table = this.getTable(options.model);
+    const fields = this.getModelFields(options.model);
+    for (const record of table.values()) {
+      if (this.matchesWhere(record, options.where, options.model, {
+        withDeleted: options.withDeleted
+      })) {
+        let result = record;
+        if (options.populate) {
+          result = this.populateRecord(record, options.model, options.populate);
+        }
+        return core.deserializeData(fields, JSON.parse(JSON.stringify(result)));
+      }
+    }
+    return null;
+  }
+  async findMany(options) {
+    const table = this.getTable(options.model);
+    let results = [];
+    for (const record of table.values()) {
+      if (this.matchesWhere(record, options.where, options.model, {
+        withDeleted: options.withDeleted
+      })) {
+        results.push(JSON.parse(JSON.stringify(record)));
+      }
+    }
+    if (options.sortBy) {
+      const { field, direction } = options.sortBy;
+      results.sort((a, b) => {
+        const valA = a[field];
+        const valB = b[field];
+        if (valA < valB) return direction === "asc" ? -1 : 1;
+        if (valA > valB) return direction === "asc" ? 1 : -1;
+        return 0;
+      });
+    }
+    if (options.offset) results = results.slice(options.offset);
+    if (options.limit) results = results.slice(0, options.limit);
+    return results;
+  }
+  async update(options) {
+    const table = this.getTable(options.model);
+    const fields = this.getModelFields(options.model);
+    const context = this.getHookContext(options.model);
+    const target = await this.findOne({ model: options.model, where: options.where });
+    if (!target) return null;
+    let updatedData = { ...target, ...options.update };
+    updatedData = await core.runHooks.beforeUpdate(this.hooks, updatedData, context);
+    const serializedUpdate = core.serializeData(fields, updatedData);
+    const mergedData = { ...target, ...serializedUpdate };
+    const clonedData = JSON.parse(JSON.stringify(mergedData));
+    table.set(String(target.id), clonedData);
+    const resultRecord = core.deserializeData(fields, clonedData);
+    await core.runHooks.afterUpdate(this.hooks, resultRecord, context);
+    return resultRecord;
+  }
+  async updateMany(options) {
+    const targets = await this.findMany({ model: options.model, where: options.where });
+    for (const target of targets) {
+      await this.update({
+        model: options.model,
+        where: [{ field: "id", value: target.id }],
+        update: options.update
+      });
+    }
+    return targets.length;
+  }
+  async delete(options) {
+    const context = this.getHookContext(options.model);
+    const definition = this.getModelDefinition(options.model);
+    await core.runHooks.beforeDelete(this.hooks, options.where, context);
+    if (definition?.softDelete) {
+      await this.updateMany({
+        model: options.model,
+        where: options.where,
+        update: { deletedAt: /* @__PURE__ */ new Date() }
+      });
+    } else {
+      const table = this.getTable(options.model);
+      const targets = await this.findMany({ model: options.model, where: options.where });
+      for (const target of targets) {
+        table.delete(String(target.id));
+      }
+    }
+    await core.runHooks.afterDelete(this.hooks, options.where, context);
+  }
+  async deleteMany(options) {
+    const targets = await this.findMany({ model: options.model, where: options.where });
+    await this.delete(options);
+    return targets.length;
+  }
+  async count(options) {
+    const results = await this.findMany({ ...options, limit: void 0, offset: void 0 });
+    return results.length;
+  }
+  clear() {
+    this.store.clear();
+  }
+  async raw(query) {
+    if (query === "clear") {
+      this.clear();
+      return true;
+    }
+    throw new Error("MemoryDbAdapter only supports 'clear' as raw query.");
+  }
+  async transaction(callback) {
+    return await callback(this);
+  }
+  /** @internal Used by runMigrations — not part of the public DatabaseAdapter contract. */
+  async __getMetadata() {
+    const metadata = [];
+    for (const [tableName, table] of this.store.entries()) {
+      const columns = /* @__PURE__ */ new Set();
+      for (const record of table.values()) {
+        Object.keys(record).forEach((k) => columns.add(k));
+      }
+      metadata.push({
+        name: tableName,
+        columns: Array.from(columns).map((name) => ({
+          name,
+          dataType: "text",
+          isNullable: true
+        }))
+      });
+    }
+    return metadata;
+  }
+  /** @internal Used by runMigrations — not part of the public DatabaseAdapter contract. */
+  async __executeMigration(operation) {
+    if (operation.type === "createTable") {
+      this.getTable(operation.table);
+    }
+  }
+};
+var KyselyDbAdapter = class _KyselyDbAdapter {
+  db;
+  config;
+  schema;
+  hooks;
+  constructor(db, options) {
+    this.db = db;
+    this.config = options.config;
+    this.schema = options.schema;
+    this.hooks = options.hooks;
+  }
+  getModelFields(model) {
+    return this.schema[model]?.fields ?? {};
+  }
+  getModelDefinition(model) {
+    return this.schema[model];
+  }
+  getHookContext(model, trx) {
+    return {
+      model,
+      adapter: this,
+      transaction: trx
+    };
+  }
+  applyWhere(qb, where, model, options) {
+    let currentQb = qb;
+    const definition = model ? this.getModelDefinition(model) : void 0;
+    if (definition?.softDelete && !options?.withDeleted) {
+      currentQb = currentQb.where("deletedAt", "is", null);
+    }
+    if (!where || where.length === 0) return currentQb;
+    for (let i = 0; i < where.length; i++) {
+      const condition = where[i];
+      if (!condition) continue;
+      const connector = i > 0 ? where[i - 1]?.connector ?? "AND" : "AND";
+      const field = condition.field;
+      let operator = condition.operator ?? "=";
+      let value = condition.value;
+      if (operator === "contains") {
+        operator = "like";
+        value = `%${value}%`;
+      } else if (operator === "starts_with") {
+        operator = "like";
+        value = `${value}%`;
+      } else if (operator === "ends_with") {
+        operator = "like";
+        value = `%${value}`;
+      } else if (operator === "not_in") {
+        operator = "not in";
+      }
+      const method = connector === "OR" ? "orWhere" : "where";
+      currentQb = currentQb[method](field, operator, value);
+    }
+    return currentQb;
+  }
+  async create(options) {
+    const fields = this.getModelFields(options.model);
+    const context = this.getHookContext(options.model);
+    let dataToInsert = options.data;
+    dataToInsert = await core.runHooks.beforeCreate(this.hooks, dataToInsert, context);
+    const serializedData = core.serializeData(fields, dataToInsert);
+    let resultRecord;
+    if (this.config.provider === "sqlite") {
+      await this.db.insertInto(options.model).values(serializedData).execute();
+      const refetched = await this.db.selectFrom(options.model).selectAll().where("id", "=", serializedData.id).executeTakeFirst();
+      resultRecord = core.deserializeData(
+        fields,
+        refetched || serializedData
+      );
+    } else {
+      const result = await this.db.insertInto(options.model).values(serializedData).returningAll().executeTakeFirst() || serializedData;
+      resultRecord = core.deserializeData(fields, result);
+    }
+    await core.runHooks.afterCreate(this.hooks, resultRecord, context);
+    return resultRecord;
+  }
+  async findOne(options) {
+    const fields = this.getModelFields(options.model);
+    let qb = this.db.selectFrom(options.model);
+    if (options.select) {
+      qb = qb.select(options.select);
+    } else {
+      qb = qb.selectAll();
+    }
+    qb = this.applyWhere(qb, options.where, options.model, { withDeleted: options.withDeleted });
+    if (options.populate) {
+      for (const relation of options.populate) {
+        const fieldDef = this.schema[options.model]?.fields[relation];
+        if (fieldDef?.references) {
+          qb = qb.leftJoin(
+            fieldDef.references.model,
+            `${options.model}.${relation}`,
+            `${fieldDef.references.model}.${fieldDef.references.field}`
+          );
+        }
+      }
+    }
+    const result = await qb.executeTakeFirst();
+    if (!result) return null;
+    return core.deserializeData(fields, result);
+  }
+  async findMany(options) {
+    const fields = this.getModelFields(options.model);
+    let qb = this.db.selectFrom(options.model);
+    if (options.select) {
+      qb = qb.select(options.select);
+    } else {
+      qb = qb.selectAll();
+    }
+    qb = this.applyWhere(qb, options.where, options.model, { withDeleted: options.withDeleted });
+    if (options.sortBy) {
+      qb = qb.orderBy(options.sortBy.field, options.sortBy.direction);
+    }
+    if (options.limit !== void 0) qb = qb.limit(options.limit);
+    if (options.offset !== void 0) qb = qb.offset(options.offset);
+    const results = await qb.execute();
+    return results.map((row) => core.deserializeData(fields, row));
+  }
+  async update(options) {
+    const fields = this.getModelFields(options.model);
+    const context = this.getHookContext(options.model);
+    const target = await this.findOne({ model: options.model, where: options.where });
+    if (!target) return null;
+    let updatedData = { ...target, ...options.update };
+    updatedData = await core.runHooks.beforeUpdate(this.hooks, updatedData, context);
+    const updatePayload = core.serializeData(fields, options.update);
+    let qb = this.db.updateTable(options.model).set(updatePayload);
+    qb = this.applyWhere(qb, options.where, options.model);
+    let resultRecord;
+    if (this.config.provider === "sqlite") {
+      await qb.execute();
+      resultRecord = core.deserializeData(fields, core.serializeData(fields, updatedData));
+    } else {
+      const result = await qb.returningAll().executeTakeFirst();
+      resultRecord = core.deserializeData(
+        fields,
+        result || core.serializeData(fields, updatedData)
+      );
+    }
+    await core.runHooks.afterUpdate(this.hooks, resultRecord, context);
+    return resultRecord;
+  }
+  async updateMany(options) {
+    const fields = this.getModelFields(options.model);
+    const updatePayload = core.serializeData(fields, options.update);
+    let qb = this.db.updateTable(options.model).set(updatePayload);
+    qb = this.applyWhere(
+      qb,
+      options.where,
+      options.model
+    );
+    const results = await qb.execute();
+    return Number(results[0]?.numUpdatedRows || 0);
+  }
+  async delete(options) {
+    const context = this.getHookContext(options.model);
+    const definition = this.getModelDefinition(options.model);
+    await core.runHooks.beforeDelete(this.hooks, options.where, context);
+    if (definition?.softDelete) {
+      await this.updateMany({
+        model: options.model,
+        where: options.where,
+        update: { deletedAt: /* @__PURE__ */ new Date() }
+      });
+    } else {
+      let qb = this.db.deleteFrom(options.model);
+      qb = this.applyWhere(qb, options.where, options.model);
+      await qb.execute();
+    }
+    await core.runHooks.afterDelete(this.hooks, options.where, context);
+  }
+  async deleteMany(options) {
+    const definition = this.getModelDefinition(options.model);
+    if (definition?.softDelete) {
+      return await this.updateMany({
+        model: options.model,
+        where: options.where,
+        update: { deletedAt: /* @__PURE__ */ new Date() }
+      });
+    }
+    let qb = this.db.deleteFrom(options.model);
+    qb = this.applyWhere(qb, options.where, options.model);
+    const results = await qb.execute();
+    return Number(results[0]?.numDeletedRows || 0);
+  }
+  async count(options) {
+    let qb = this.db.selectFrom(options.model);
+    qb = this.applyWhere(qb, options.where, options.model);
+    const { count } = this.db.fn;
+    qb = qb.select(count("id").as("c"));
+    const result = await qb.executeTakeFirst();
+    return Number(result?.c || 0);
+  }
+  async raw(query, params) {
+    const result = await kysely.sql.raw(query, params).execute(this.db);
+    return result.rows;
+  }
+  async transaction(callback) {
+    return await this.db.transaction().execute(async (trx) => {
+      const trxAdapter = new _KyselyDbAdapter(trx, {
+        config: this.config,
+        schema: this.schema,
+        hooks: this.hooks
+      });
+      return await callback(trxAdapter);
+    });
+  }
+  /** @internal Used by runMigrations — not part of the public DatabaseAdapter contract. */
+  async __getMetadata() {
+    const tables = await this.db.introspection.getTables();
+    const dialect = this.__getDialect();
+    let filtered = tables;
+    if (dialect === "postgres") {
+      const currentSchema = await this.getPostgresSchema();
+      filtered = tables.filter((table) => {
+        const schema = table.schema;
+        return !schema || schema === currentSchema;
+      });
+    }
+    return filtered.map((table) => ({
+      name: table.name,
+      columns: table.columns.map((col) => ({
+        name: col.name,
+        dataType: col.dataType,
+        isNullable: col.isNullable ?? true
+      }))
+    }));
+  }
+  async getPostgresSchema() {
+    try {
+      const result = await kysely.sql`SHOW search_path`.execute(this.db);
+      const searchPath = result.rows[0]?.search_path ?? result.rows[0]?.searchPath;
+      if (!searchPath) return "public";
+      const schemas = searchPath.split(",").map((s) => s.trim()).map((s) => s.replace(/^["']|["']$/g, "")).filter((s) => !s.startsWith("$") && !s.startsWith("\\$"));
+      return schemas[0] || "public";
+    } catch {
+      return "public";
+    }
+  }
+  /** @internal Used by runMigrations to auto-detect the SQL dialect. */
+  __getDialect() {
+    switch (this.config.provider) {
+      case "pg":
+        return "postgres";
+      case "mysql":
+        return "mysql";
+      case "sqlite":
+        return "sqlite";
+      default:
+        return "postgres";
+    }
+  }
+  /** @internal Used by runMigrations — not part of the public DatabaseAdapter contract. */
+  async __executeMigration(operation) {
+    const dialect = this.__getDialect();
+    if (operation.type === "createTable") {
+      let builder = this.db.schema.createTable(operation.table).ifNotExists();
+      for (const [name, field] of Object.entries(operation.definition.fields)) {
+        const type = core.getColumnType(field, dialect);
+        builder = builder.addColumn(name, type, (col) => {
+          if (field.primaryKey) col = col.primaryKey();
+          if (field.required) col = col.notNull();
+          if (field.unique) col = col.unique();
+          if (field.references) {
+            col = col.references(`${field.references.model}.${field.references.field}`).onDelete(field.references.onDelete || "cascade");
+          }
+          return col;
+        });
+      }
+      await builder.execute();
+      if (operation.definition.indexes) {
+        for (const index of operation.definition.indexes) {
+          const indexName = `idx_${operation.table}_${index.fields.join("_")}`;
+          let indexBuilder = this.db.schema.createIndex(indexName).on(operation.table).columns(index.fields);
+          if (index.unique) {
+            indexBuilder = indexBuilder.unique();
+          }
+          await indexBuilder.execute();
+        }
+      }
+    } else if (operation.type === "addColumn") {
+      const type = core.getColumnType(operation.definition, dialect);
+      await this.db.schema.alterTable(operation.table).addColumn(operation.field, type, (col) => {
+        if (operation.definition.required) col = col.notNull();
+        if (operation.definition.unique) col = col.unique();
+        if (operation.definition.references) {
+          col = col.references(
+            `${operation.definition.references.model}.${operation.definition.references.field}`
+          ).onDelete(operation.definition.references.onDelete || "cascade");
+        }
+        return col;
+      }).execute();
+    } else if (operation.type === "createIndex") {
+      let builder = this.db.schema.createIndex(operation.name).on(operation.table).columns(operation.fields);
+      if (operation.unique) {
+        builder = builder.unique();
+      }
+      await builder.execute();
+    }
+  }
+};
+
+// src/index.ts
+function memoryDatabase() {
+  const adapter = new MemoryDbAdapter();
+  return new Proxy(adapter, {
+    get(target, prop, receiver) {
+      if (prop === "get") {
+        return async (key) => {
+          const res = await adapter.findOne({
+            model: "legacy",
+            where: [{ field: "id", value: key }]
+          });
+          return res;
+        };
+      }
+      if (prop === "put") {
+        return async (key, data) => {
+          await adapter.create({ model: "legacy", data: { id: key, ...data } });
+        };
+      }
+      if (prop === "delete") {
+        return async (key) => {
+          await adapter.delete({ model: "legacy", where: [{ field: "id", value: key }] });
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+Object.defineProperty(exports, "MongoDbAdapter", {
+  enumerable: true,
+  get: function () { return mongodbAdapter.MongoDbAdapter; }
+});
+Object.defineProperty(exports, "mongodbAdapter", {
+  enumerable: true,
+  get: function () { return mongodbAdapter.mongodbAdapter; }
+});
+exports.KyselyDbAdapter = KyselyDbAdapter;
+exports.MemoryDbAdapter = MemoryDbAdapter;
+exports.memoryDatabase = memoryDatabase;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map