jazz-tools 0.18.14 → 0.18.16

package/dist/better-auth/database-adapter/index.js

@@ -0,0 +1,920 @@
+// src/better-auth/database-adapter/index.ts
+import { createAdapter } from "better-auth/adapters";
+import { startWorker } from "jazz-tools/worker";
+
+// src/better-auth/database-adapter/utils.ts
+function filterListByWhere(data, where) {
+  if (!Array.isArray(data)) {
+    throw new Error("Expected data to be an array");
+  }
+  if (where === void 0) {
+    return data;
+  }
+  if (!Array.isArray(where)) {
+    throw new Error("Expected where to be an array");
+  }
+  function evaluateCondition(item, condition) {
+    const { field, operator, value } = condition;
+    const itemValue = field === "id" ? item.$jazz.id : item[field];
+    switch (operator) {
+      case "eq":
+        return itemValue === value;
+      case "ne":
+        return itemValue !== value;
+      case "lt":
+        return value !== null && itemValue < value;
+      case "lte":
+        return value !== null && itemValue <= value;
+      case "gt":
+        return value !== null && itemValue > value;
+      case "gte":
+        return value !== null && itemValue >= value;
+      case "in":
+        return Array.isArray(value) ? value.includes(itemValue) : false;
+      case "contains":
+        return typeof itemValue === "string" && typeof value === "string" ? itemValue.includes(value) : false;
+      case "starts_with":
+        return typeof itemValue === "string" && typeof value === "string" ? itemValue.startsWith(value) : false;
+      case "ends_with":
+        return typeof itemValue === "string" && typeof value === "string" ? itemValue.endsWith(value) : false;
+      default:
+        throw new Error(`Unsupported operator: ${operator}`);
+    }
+  }
+  return data.filter((item) => {
+    let result = true;
+    for (let i = 0; i < where.length; i++) {
+      const condition = where[i];
+      const matches = evaluateCondition(item, condition);
+      if (i === 0) {
+        result = matches;
+      } else {
+        const connector = condition.connector || "AND";
+        if (connector === "AND") {
+          result = result && matches;
+        } else if (connector === "OR") {
+          result = result || matches;
+        } else {
+          throw new Error(`Unsupported connector: ${connector}`);
+        }
+      }
+    }
+    return result;
+  });
+}
+function sortListByField(data, sort) {
+  if (!sort) {
+    return data;
+  }
+  const { field, direction } = sort;
+  data.sort((a, b) => {
+    if (a === null || b === null) {
+      return 0;
+    }
+    if (typeof a[field] === "string" && typeof b[field] === "string") {
+      return direction === "asc" ? a[field].localeCompare(b[field]) : b[field].localeCompare(a[field]);
+    }
+    return direction === "asc" ? a[field] - b[field] : b[field] - a[field];
+  });
+  return data;
+}
+function paginateList(data, limit, offset) {
+  if (offset === void 0 && limit === void 0) {
+    return data;
+  }
+  if (limit === 0) {
+    return [];
+  }
+  let start = offset ?? 0;
+  if (start < 0) {
+    start = 0;
+  }
+  const end = limit ? start + limit : void 0;
+  return data.slice(start, end);
+}
+function isWhereByField(field, where) {
+  return where.field === field && where.operator === "eq" && where.connector === "AND";
+}
+function isWhereBySingleField(field, where) {
+  if (where === void 0 || where.length !== 1) {
+    return false;
+  }
+  const [cond] = where;
+  if (!cond) {
+    return false;
+  }
+  return isWhereByField(field, cond);
+}
+function containWhereByField(field, where) {
+  if (where === void 0) {
+    return false;
+  }
+  return where.some((cond) => isWhereByField(field, cond));
+}
+function extractWhereByField(field, where) {
+  if (where === void 0) {
+    return [void 0, []];
+  }
+  return [
+    where.find((cond) => isWhereByField(field, cond)),
+    where.filter((cond) => !isWhereByField(field, cond))
+  ];
+}
+
+// src/better-auth/database-adapter/repository/generic.ts
+var JazzRepository = class {
+  constructor(databaseSchema, databaseRoot, worker, betterAuthSchema = {}, ensureSync = false) {
+    this.coValuesTracker = void 0;
+    this.databaseSchema = databaseSchema;
+    this.databaseRoot = databaseRoot;
+    this.worker = worker;
+    this.owner = databaseRoot.group;
+    this.betterAuthSchema = betterAuthSchema;
+    if (ensureSync)
+      this.coValuesTracker = worker.$jazz.raw.core.node.syncManager.trackDirtyCoValues();
+  }
+  ensureSync() {
+    if (!this.coValuesTracker)
+      throw new Error("Repository wasn't initialized with ensureSync option");
+    return Promise.all(
+      Array.from(
+        this.coValuesTracker.done(),
+        (id) => this.worker.$jazz.raw.core.node.syncManager.waitForSync(id)
+      )
+    );
+  }
+  async create(model, data, uniqueId) {
+    const schema = this.getSchema(model);
+    const resolved = await this.databaseRoot.$jazz.ensureLoaded({
+      resolve: {
+        tables: {
+          [model]: true
+        }
+      }
+    });
+    const list = resolved.tables?.[model];
+    if (!uniqueId) {
+      const node2 = schema.create(data, {
+        owner: list.$jazz.owner
+      });
+      list.$jazz.push(node2);
+      return node2;
+    }
+    const existingNode = await schema.loadUnique(
+      uniqueId,
+      list.$jazz.owner.$jazz.id,
+      {
+        loadAs: this.worker
+      }
+    );
+    if (existingNode && existingNode.$jazz?.raw.get("_deleted") !== true) {
+      throw new Error("Entity already exists");
+    }
+    const node = await schema.upsertUnique({
+      value: {
+        ...data,
+        _deleted: false
+      },
+      owner: list.$jazz.owner,
+      unique: uniqueId
+    });
+    if (!node) {
+      throw new Error("Unable to create entity");
+    }
+    list.$jazz.push(node);
+    return node;
+  }
+  async findOne(model, where) {
+    return this.findMany(model, where, 1).then((users) => users?.at(0) ?? null);
+  }
+  async findById(model, where) {
+    const id = where[0].value;
+    if (!id.startsWith("co_")) {
+      return null;
+    }
+    const node = await this.getSchema(model).load(id, { loadAs: this.worker });
+    if (!node) {
+      return null;
+    }
+    if (node.$jazz.raw.get("_deleted")) {
+      return null;
+    }
+    return node;
+  }
+  async findByUnique(model, where) {
+    const value = where[0].value;
+    const node = await this.getSchema(model).loadUnique(
+      value,
+      this.owner.$jazz.id,
+      {
+        loadAs: this.worker
+      }
+    );
+    if (!node) {
+      return null;
+    }
+    if (node.$jazz.raw.get("_deleted")) {
+      return null;
+    }
+    return node;
+  }
+  async findMany(model, where, limit, sortBy, offset) {
+    this.getSchema(model);
+    if (isWhereBySingleField("id", where)) {
+      return this.findById(model, where).then((node) => node ? [node] : []);
+    }
+    const resolvedRoot = await this.databaseRoot.$jazz.ensureLoaded({
+      resolve: {
+        tables: {
+          [model]: {
+            $each: true
+          }
+        }
+      }
+    });
+    const list = resolvedRoot.tables?.[model];
+    if (!list) {
+      return [];
+    }
+    return this.filterSortPaginateList(list, where, limit, sortBy, offset);
+  }
+  async update(model, where, update) {
+    const nodes = await this.findMany(model, where);
+    if (nodes.length === 0) {
+      return [];
+    }
+    for (const node of nodes) {
+      for (const [key, value] of Object.entries(
+        update
+      )) {
+        node.$jazz.set(key, value);
+      }
+    }
+    return nodes;
+  }
+  async deleteValue(model, where) {
+    const items = await this.findMany(model, where);
+    if (items.length === 0) {
+      return 0;
+    }
+    const resolved = await this.databaseRoot.$jazz.ensureLoaded({
+      resolve: {
+        tables: {
+          [model]: {
+            $each: true
+          }
+        }
+      }
+    });
+    if (!resolved) {
+      throw new Error("Unable to load values");
+    }
+    const list = resolved?.tables?.[model];
+    for (const toBeDeleted of items) {
+      const index = [...list.entries()].findIndex(
+        ([_, value]) => value && value.$jazz.id === toBeDeleted.$jazz.id
+      );
+      toBeDeleted.$jazz.set("_deleted", true);
+      if (index !== -1) {
+        list.$jazz.remove(index);
+      }
+    }
+    return items.length;
+  }
+  async count(model, where) {
+    return this.findMany(model, where).then((values) => values.length);
+  }
+  getSchema(model) {
+    const schema = this.databaseSchema.shape.tables.shape[model]?.element;
+    if (!schema) {
+      throw new Error(`Schema for model "${model}" not found`);
+    }
+    return schema;
+  }
+  filterSortPaginateList(list, where, limit, sortBy, offset) {
+    return [
+      list.filter(
+        (item) => item !== null && item.$jazz.raw.get("_deleted") !== true
+      )
+    ].map((list2) => filterListByWhere(list2, where)).map((list2) => sortListByField(list2, sortBy)).map((list2) => paginateList(list2, limit, offset)).at(0);
+  }
+};
+
+// src/better-auth/database-adapter/repository/user.ts
+import { co, z } from "jazz-tools";
+var EmailIndex = co.map({ user: z.string().nullable() });
+var UserRepository = class extends JazzRepository {
+  /**
+   * Custom logic:
+   * - sessions are stored inside the user object
+   * - keep sync email index
+   */
+  async create(model, data, uniqueId) {
+    const SessionListSchema = this.databaseSchema.shape.tables.shape.session;
+    if (!SessionListSchema) {
+      throw new Error("Session list schema not found");
+    }
+    const userEmail = data[this.getEmailProperty()];
+    const emailIndex = await this.loadEmailIndex(userEmail);
+    if (emailIndex?.user) {
+      throw new Error("Email already exists");
+    }
+    const user = await super.create(model, data, uniqueId);
+    await this.updateEmailIndex(userEmail, user.$jazz.id);
+    user.$jazz.set(
+      "sessions",
+      co.list(SessionListSchema).create([], user.$jazz.owner)
+    );
+    return user;
+  }
+  /**
+   * Custom logic:
+   * - if the email is in the where clause, find by email
+   */
+  async findMany(model, where, limit, sortBy, offset) {
+    if (isWhereBySingleField("email", where)) {
+      return this.findByEmail(where[0].value);
+    }
+    return super.findMany(model, where, limit, sortBy, offset);
+  }
+  getEmailProperty() {
+    return this.betterAuthSchema.user?.fields.email?.fieldName || "email";
+  }
+  async findByEmail(email) {
+    const emailIndex = await this.loadEmailIndex(email);
+    const user = emailIndex?.user;
+    if (!user) {
+      return [];
+    }
+    return this.findById("user", [
+      { field: "id", operator: "eq", value: user, connector: "AND" }
+    ]).then((user2) => user2 ? [user2] : []);
+  }
+  /**
+   * Custom logic:
+   * - if the email is changed, update the email index
+   */
+  async update(model, where, update) {
+    const nodes = await this.findMany(model, where);
+    if (nodes.length === 0) {
+      return [];
+    }
+    const newEmail = update[this.getEmailProperty()];
+    for (const node of nodes) {
+      const oldEmail = node.$jazz.raw.get(this.getEmailProperty());
+      for (const [key, value] of Object.entries(
+        update
+      )) {
+        node.$jazz.set(key, value);
+      }
+      if (oldEmail !== newEmail && oldEmail !== void 0 && newEmail !== void 0) {
+        await this.updateEmailIndex(oldEmail, null);
+        await this.updateEmailIndex(newEmail, node.$jazz.id);
+      }
+    }
+    return nodes;
+  }
+  async deleteValue(model, where) {
+    const nodes = await this.findMany(model, where);
+    const deleted = await super.deleteValue(model, where);
+    for (const node of nodes) {
+      const email = node.$jazz.raw.get(this.getEmailProperty());
+      if (email) {
+        await this.updateEmailIndex(email, null);
+      }
+    }
+    return deleted;
+  }
+  async loadEmailIndex(email) {
+    const emailIndex = await EmailIndex.loadUnique(email, this.owner.$jazz.id, {
+      loadAs: this.worker
+    });
+    return emailIndex;
+  }
+  async updateEmailIndex(email, userId) {
+    await EmailIndex.upsertUnique({
+      value: {
+        user: userId
+      },
+      unique: email,
+      owner: this.owner
+    });
+  }
+};
+
+// src/better-auth/database-adapter/repository/session.ts
+var SessionRepository = class extends JazzRepository {
+  constructor(databaseSchema, databaseRoot, worker, betterAuthSchema = {}, ensureSync = false) {
+    super(databaseSchema, databaseRoot, worker, betterAuthSchema, ensureSync);
+    this.userRepository = new UserRepository(
+      databaseSchema,
+      databaseRoot,
+      worker,
+      betterAuthSchema
+    );
+  }
+  /**
+   * Custom logic: sessions are stored inside the user object
+   */
+  async create(model, data, uniqueId) {
+    if (typeof data.token !== "string" || typeof data.userId !== "string") {
+      throw new Error("Token and userId are required for session creation");
+    }
+    const user = await this.userRepository.findById("user", [
+      {
+        field: "id",
+        operator: "eq",
+        value: data.userId,
+        connector: "AND"
+      }
+    ]);
+    if (!user) {
+      throw new Error("User not found");
+    }
+    const { sessions } = await user.$jazz.ensureLoaded({
+      resolve: {
+        sessions: true
+      }
+    });
+    const session = this.getSchema("session").create(data, {
+      unique: data.token,
+      owner: this.owner
+    });
+    sessions.$jazz.push(session);
+    return session;
+  }
+  /**
+   * Custom logic: sessions are stored inside the user object.
+   */
+  async findMany(model, where, limit, sortBy, offset) {
+    if (isWhereBySingleField("id", where)) {
+      return this.findById(model, where).then((node) => node ? [node] : []);
+    }
+    if (isWhereBySingleField("token", where)) {
+      return this.findByUnique(model, where).then(
+        (node) => node ? [node] : []
+      );
+    }
+    if (containWhereByField("userId", where)) {
+      const [userIdWhere, otherWhere] = extractWhereByField("userId", where);
+      const user = await this.userRepository.findById("user", [
+        {
+          field: "id",
+          operator: "eq",
+          value: userIdWhere.value,
+          connector: "AND"
+        }
+      ]);
+      if (!user) {
+        console.warn("Trying to find user's sessions, but user not found");
+        return [];
+      }
+      const { sessions } = await user.$jazz.ensureLoaded({
+        resolve: {
+          sessions: {
+            $each: true
+          }
+        }
+      });
+      return this.filterSortPaginateList(
+        sessions,
+        otherWhere,
+        limit,
+        sortBy,
+        offset
+      );
+    }
+    throw new Error(
+      "Unable to find session with where: " + JSON.stringify(where)
+    );
+  }
+  /**
+   * Custom logic: sessions are stored inside the user object.
+   */
+  async deleteValue(model, where) {
+    const items = await this.findMany(model, where);
+    if (items.length === 0) {
+      return 0;
+    }
+    const userId = items[0].userId;
+    return this.deleteSession(userId, items);
+  }
+  async deleteSession(userId, items) {
+    const user = await this.userRepository.findById("user", [
+      {
+        field: "id",
+        operator: "eq",
+        value: userId,
+        connector: "AND"
+      }
+    ]);
+    if (!user) {
+      throw new Error("User not found");
+    }
+    const { sessions } = await user.$jazz.ensureLoaded({
+      resolve: {
+        sessions: true
+      }
+    });
+    for (const toBeDeleted of items) {
+      const index = [...sessions.entries()].findIndex(
+        ([_, value]) => value && value.$jazz.id === toBeDeleted.$jazz.id
+      );
+      toBeDeleted.$jazz.set("_deleted", true);
+      if (index !== -1) {
+        sessions.$jazz.remove(index);
+      }
+    }
+    return items.length;
+  }
+};
+
+// src/better-auth/database-adapter/repository/verification.ts
+var VerificationRepository = class extends JazzRepository {
+  /**
+   * Custom logic: property identifier is used as uniqueId
+   */
+  async create(model, data, uniqueId) {
+    return super.create(model, data, data["identifier"]);
+  }
+  /**
+   * Custom logic: property identifier is used as uniqueId
+   * If we look for identifier, we use findByUnique instead of findMany
+   */
+  async findMany(model, where, limit, sortBy, offset) {
+    if (isWhereBySingleField("identifier", where)) {
+      return this.findByUnique(model, where).then(
+        (node) => node ? [node] : []
+      );
+    }
+    return super.findMany(model, where, limit, sortBy, offset);
+  }
+};
+
+// src/better-auth/database-adapter/repository/account.ts
+import { co as co2, z as z2 } from "jazz-tools";
+var AccountIdIndex = co2.list(z2.string());
+var AccountRepository = class extends JazzRepository {
+  /**
+   * Custom logic:
+   * - keep sync accountId index
+   */
+  async create(model, data, uniqueId) {
+    const account = await super.create(model, data, uniqueId);
+    await this.updateAccountIdIndex(
+      account[this.getAccountIdProperty()],
+      account.$jazz.id
+    );
+    return account;
+  }
+  /**
+   * Custom logic:
+   * - if the accountId is in the where clause, get the ids from the index
+   */
+  async findMany(model, where, limit, sortBy, offset) {
+    if (isWhereBySingleField(this.getAccountIdProperty(), where)) {
+      const accountIdIndex = await this.getAccountIdIndex(where[0].value);
+      const ids = accountIdIndex ?? [];
+      if (ids.length === 0) {
+        return [];
+      }
+      const results = await Promise.all(
+        ids.map(
+          (id) => super.findById(model, [
+            { field: "id", operator: "eq", value: id, connector: "AND" }
+          ])
+        )
+      );
+      return results.filter((value) => value !== null);
+    }
+    return super.findMany(model, where, limit, sortBy, offset);
+  }
+  async deleteValue(model, where) {
+    const nodes = await this.findMany(model, where);
+    const deleted = await super.deleteValue(model, where);
+    for (const node of nodes) {
+      const accountId = node.$jazz.raw.get(this.getAccountIdProperty());
+      if (accountId) {
+        await this.deleteAccountIdIndex(accountId, node.$jazz.id);
+      }
+    }
+    return deleted;
+  }
+  async getAccountIdIndex(accountId) {
+    const indexUnique = this.getAccountIdProperty() + "_" + accountId;
+    const accountIdIndex = await AccountIdIndex.loadUnique(
+      indexUnique,
+      this.owner.$jazz.id,
+      {
+        loadAs: this.worker
+      }
+    );
+    return accountIdIndex;
+  }
+  async updateAccountIdIndex(accountId, entityId) {
+    const accountIdIndex = await this.getAccountIdIndex(accountId);
+    const ids = accountIdIndex ?? [];
+    await AccountIdIndex.upsertUnique({
+      value: [...ids, entityId],
+      unique: this.getAccountIdProperty() + "_" + accountId,
+      owner: this.owner
+    });
+  }
+  async deleteAccountIdIndex(accountId, entityId) {
+    const accountIdIndex = await this.getAccountIdIndex(accountId);
+    const ids = accountIdIndex ?? [];
+    await AccountIdIndex.upsertUnique({
+      value: ids.filter((id) => id !== entityId),
+      unique: this.getAccountIdProperty() + "_" + accountId,
+      owner: this.owner
+    });
+  }
+  getAccountIdProperty() {
+    return this.betterAuthSchema.account?.fields.accountId?.fieldName || "accountId";
+  }
+};
+
+// src/better-auth/database-adapter/schema.ts
+import { Group, co as co3, z as z3 } from "jazz-tools";
+var DATABASE_ROOT_ID = "better-auth-root";
+function createJazzSchema(schema) {
+  const tablesSchema = generateSchemaFromBetterAuthSchema(schema);
+  const DatabaseRoot = co3.map({
+    group: Group,
+    tables: co3.map(tablesSchema)
+  });
+  const WorkerAccount = co3.account({
+    profile: co3.profile(),
+    root: co3.map({})
+  }).withMigration(async (account) => {
+    const dbRoot = await DatabaseRoot.loadUnique(
+      DATABASE_ROOT_ID,
+      account.$jazz.id,
+      {
+        resolve: {
+          group: true,
+          tables: true
+        },
+        loadAs: account
+      }
+    );
+    if (!dbRoot) {
+      const adminGroup = Group.create({ owner: account });
+      await DatabaseRoot.upsertUnique({
+        value: {
+          group: adminGroup,
+          // create empty tables for each model
+          tables: co3.map(tablesSchema).create(
+            Object.fromEntries(
+              Object.entries(tablesSchema).map(([key, value]) => [
+                key,
+                value.create([], adminGroup)
+              ])
+            ),
+            adminGroup
+          )
+        },
+        unique: DATABASE_ROOT_ID,
+        owner: account
+      });
+    } else {
+      for (const [key, value] of Object.entries(
+        DatabaseRoot.shape.tables.shape
+      )) {
+        if (dbRoot.tables[key] === void 0) {
+          dbRoot.tables.$jazz.set(key, value.create([], dbRoot.group));
+        }
+      }
+    }
+  });
+  return {
+    WorkerAccount,
+    DatabaseRoot,
+    betterAuthSchema: schema,
+    async loadDatabase(account, options) {
+      if (options?.resolve === false || typeof options?.resolve === "object" && options?.resolve.group !== true) {
+        throw new Error("Group is required to load the database");
+      }
+      const db = await DatabaseRoot.loadUnique(
+        DATABASE_ROOT_ID,
+        account.$jazz.id,
+        {
+          resolve: {
+            group: true,
+            tables: true
+          },
+          loadAs: account,
+          ...options
+        }
+      );
+      if (!db) {
+        throw new Error("Database not found");
+      }
+      return db;
+    }
+  };
+}
+function generateSchemaFromBetterAuthSchema(schema) {
+  const tablesSchema = {};
+  for (const [key, value] of Object.entries(schema)) {
+    const modelShape = {
+      _deleted: z3.boolean()
+    };
+    for (const [fieldName, field] of Object.entries(value.fields)) {
+      modelShape[field.fieldName || fieldName] = convertFieldToCoValue(field);
+    }
+    const coMap = co3.map(modelShape);
+    tablesSchema[key] = co3.list(coMap);
+  }
+  if (tablesSchema["user"] && tablesSchema["session"]) {
+    tablesSchema["user"] = co3.list(
+      co3.map({
+        ...tablesSchema["user"].element.shape,
+        sessions: tablesSchema["session"]
+      }).withMigration((user) => {
+        if (user.sessions === void 0) {
+          user.$jazz.set(
+            "sessions",
+            tablesSchema["session"].create([], user.$jazz.owner)
+          );
+        }
+      })
+    );
+  } else {
+    throw new Error(
+      "Cannot find user and session tables, sessions will not be persisted"
+    );
+  }
+  return tablesSchema;
+}
+function convertFieldToCoValue(field) {
+  let zodType;
+  switch (field.type) {
+    case "string":
+      zodType = z3.string();
+      break;
+    case "number":
+      zodType = z3.number();
+      break;
+    case "boolean":
+      zodType = z3.boolean();
+      break;
+    case "date":
+      zodType = z3.date();
+      break;
+    default:
+      throw new Error(`Unsupported field type: ${field.type}`);
+  }
+  if (field.required === false) {
+    zodType = zodType.optional();
+  }
+  return zodType;
+}
+function tableItem2Record(tableItem) {
+  if (!tableItem) {
+    return tableItem;
+  }
+  const { $jazz, ...rest } = tableItem;
+  return {
+    ...rest,
+    id: $jazz.id
+  };
+}
+
+// src/better-auth/database-adapter/index.ts
+var JazzBetterAuthDatabaseAdapter = (config) => createAdapter({
+  config: {
+    adapterId: "jazz-tools-adapter",
+    // A unique identifier for the adapter.
+    adapterName: "Jazz Tools Adapter",
+    // The name of the adapter.
+    debugLogs: config.debugLogs ?? false,
+    // Whether to enable debug logs.
+    supportsJSON: true,
+    // Whether the database supports JSON. (Default: false)
+    supportsDates: true,
+    // Whether the database supports dates. (Default: true)
+    supportsBooleans: true,
+    // Whether the database supports booleans. (Default: true)
+    supportsNumericIds: false,
+    // Whether the database supports auto-incrementing numeric IDs. (Default: true)
+    disableIdGeneration: true
+  },
+  adapter: ({ schema }) => {
+    const JazzSchema = createJazzSchema(schema);
+    let worker = void 0;
+    async function getWorker() {
+      if (worker) {
+        return worker;
+      }
+      const result = await startWorker({
+        AccountSchema: JazzSchema.WorkerAccount,
+        syncServer: config.syncServer,
+        accountID: config.accountID,
+        accountSecret: config.accountSecret,
+        skipInboxLoad: true,
+        asActiveAccount: false
+      });
+      worker = result.worker;
+      return worker;
+    }
+    async function initRepository(model, ensureSync = false) {
+      let Repository = void 0;
+      switch (model) {
+        case "user":
+          Repository = UserRepository;
+          break;
+        case "session":
+          Repository = SessionRepository;
+          break;
+        case "verification":
+          Repository = VerificationRepository;
+          break;
+        case "account":
+          Repository = AccountRepository;
+          break;
+      }
+      if (!Repository) {
+        Repository = JazzRepository;
+      }
+      const worker2 = await getWorker();
+      const database = await JazzSchema.loadDatabase(worker2);
+      const repository = new Repository(
+        JazzSchema.DatabaseRoot,
+        database,
+        worker2,
+        schema,
+        ensureSync
+      );
+      return repository;
+    }
+    return {
+      create: async ({ data, model, select }) => {
+        const repository = await initRepository(model, true);
+        const created = await repository.create(model, data);
+        await repository.ensureSync();
+        return tableItem2Record(created);
+      },
+      update: async ({ model, where, update }) => {
+        const repository = await initRepository(model, true);
+        const updated = await repository.update(
+          model,
+          where,
+          update
+        );
+        if (updated.length === 0) {
+          return null;
+        }
+        await repository.ensureSync();
+        return tableItem2Record(updated[0]);
+      },
+      updateMany: async ({ model, where, update }) => {
+        const repository = await initRepository(model, true);
+        const updated = await repository.update(model, where, update);
+        await repository.ensureSync();
+        return updated.length;
+      },
+      delete: async ({ model, where }) => {
+        const repository = await initRepository(model, true);
+        await repository.deleteValue(model, where);
+        await repository.ensureSync();
+      },
+      findOne: async ({ model, where }) => {
+        const repository = await initRepository(model);
+        const item = await repository.findOne(model, where);
+        return tableItem2Record(item);
+      },
+      findMany: async ({
+        model,
+        where,
+        limit,
+        sortBy,
+        offset
+      }) => {
+        const repository = await initRepository(model);
+        const items = await repository.findMany(
+          model,
+          where,
+          limit,
+          sortBy,
+          offset
+        );
+        return items.map(tableItem2Record);
+      },
+      deleteMany: async ({ model, where }) => {
+        const repository = await initRepository(model, true);
+        const deleted = await repository.deleteValue(model, where);
+        await repository.ensureSync();
+        return deleted;
+      },
+      count: async ({ model, where }) => {
+        const repository = await initRepository(model);
+        return repository.count(model, where);
+      }
+    };
+  }
+});
+export {
+  JazzBetterAuthDatabaseAdapter
+};
+//# sourceMappingURL=index.js.map