jazz-tools 0.18.15 → 0.18.17

package/src/better-auth/database-adapter/repository/account.ts

@@ -0,0 +1,131 @@
+import { CleanedWhere } from "better-auth/adapters";
+import { co, z } from "jazz-tools";
+import { JazzRepository } from "./generic";
+import { isWhereBySingleField } from "../utils";
+import type { TableItem } from "../schema";
+
+/**
+ * This list stores an array of covalues ID
+ * mapped by the accountID property.
+ * Because accountId is not unique, and it is used on every social login
+ */
+const AccountIdIndex = co.list(z.string());
+
+export class AccountRepository extends JazzRepository {
+  /**
+   * Custom logic:
+   * - keep sync accountId index
+   */
+  async create(
+    model: string,
+    data: Record<string, any>,
+    uniqueId?: string,
+  ): Promise<TableItem> {
+    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: string,
+    where: CleanedWhere[] | undefined,
+    limit?: number,
+    sortBy?: { field: string; direction: "asc" | "desc" },
+    offset?: number,
+  ): Promise<TableItem[]> {
+    if (isWhereBySingleField(this.getAccountIdProperty(), where)) {
+      const accountIdIndex = await this.getAccountIdIndex(where[0].value);
+
+      const ids = accountIdIndex ?? [];
+
+      if (ids.length === 0) {
+        return [];
+      }
+
+      // except for accountId clashing from different social providers,
+      // ids should contain a single id, max two
+      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: string, where: CleanedWhere[]): Promise<number> {
+    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()) as
+        | string
+        | undefined;
+
+      if (accountId) {
+        await this.deleteAccountIdIndex(accountId, node.$jazz.id);
+      }
+    }
+
+    return deleted;
+  }
+
+  private async getAccountIdIndex(accountId: string) {
+    const indexUnique = this.getAccountIdProperty() + "_" + accountId;
+
+    const accountIdIndex = await AccountIdIndex.loadUnique(
+      indexUnique,
+      this.owner.$jazz.id,
+      {
+        loadAs: this.worker,
+      },
+    );
+
+    return accountIdIndex;
+  }
+
+  private async updateAccountIdIndex(accountId: string, entityId: string) {
+    const accountIdIndex = await this.getAccountIdIndex(accountId);
+
+    const ids = accountIdIndex ?? [];
+
+    await AccountIdIndex.upsertUnique({
+      value: [...ids, entityId],
+      unique: this.getAccountIdProperty() + "_" + accountId,
+      owner: this.owner,
+    });
+  }
+
+  private async deleteAccountIdIndex(accountId: string, entityId: string) {
+    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,
+    });
+  }
+
+  private getAccountIdProperty(): string {
+    return (
+      this.betterAuthSchema.account?.fields.accountId?.fieldName || "accountId"
+    );
+  }
+}

package/src/better-auth/database-adapter/repository/generic.ts

@@ -0,0 +1,297 @@
+import { CleanedWhere } from "better-auth/adapters";
+import { BetterAuthDbSchema } from "better-auth/db";
+import { Account, CoList, CoMap, Group, co } from "jazz-tools";
+import type { Database, TableItem } from "../schema.js";
+import {
+  filterListByWhere,
+  isWhereBySingleField,
+  paginateList,
+  sortListByField,
+} from "../utils.js";
+
+export class JazzRepository {
+  protected databaseSchema: Database;
+  protected databaseRoot: co.loaded<Database, { group: true }>;
+  protected worker: Account;
+  protected owner: Group;
+  protected betterAuthSchema: BetterAuthDbSchema;
+
+  private coValuesTracker:
+    | {
+        done: () => Set<`co_z${string}`>;
+      }
+    | undefined = undefined;
+
+  constructor(
+    databaseSchema: Database,
+    databaseRoot: co.loaded<Database, { group: true }>,
+    worker: Account,
+    betterAuthSchema: BetterAuthDbSchema = {},
+    ensureSync: boolean = false,
+  ) {
+    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: string,
+    data: Record<string, any>,
+    uniqueId?: string,
+  ): Promise<TableItem> {
+    const schema = this.getSchema(model);
+
+    const resolved = await this.databaseRoot.$jazz.ensureLoaded({
+      resolve: {
+        tables: {
+          [model]: true,
+        },
+      },
+    });
+
+    const list = resolved.tables?.[model] as unknown as CoList<CoMap>;
+
+    if (!uniqueId) {
+      // Use the same owner of the table.
+      const node = schema.create(data, {
+        owner: list.$jazz.owner,
+      });
+
+      list.$jazz.push(node);
+
+      return node;
+    }
+
+    // If we have a unique id, we must check for soft deleted items first
+    const existingNode = (await schema.loadUnique(
+      uniqueId,
+      list.$jazz.owner.$jazz.id,
+      {
+        loadAs: this.worker,
+      },
+    )) as CoMap | null;
+
+    // if the entity exists and is not soft deleted, we must throw an error
+    if (existingNode && existingNode.$jazz?.raw.get("_deleted") !== true) {
+      throw new Error("Entity already exists");
+    }
+
+    // create the entity or update the deleted one
+    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: string,
+    where: CleanedWhere[],
+  ): Promise<TableItem | null> {
+    return this.findMany(model, where, 1).then((users) => users?.at(0) ?? null);
+  }
+
+  async findById(
+    model: string,
+    where: [{ field: "id"; operator: "eq"; value: string; connector: "AND" }],
+  ): Promise<TableItem | null> {
+    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: string,
+    where: [{ field: string; operator: "eq"; value: string; connector: "AND" }],
+  ): Promise<TableItem | null> {
+    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: string,
+    where: CleanedWhere[] | undefined,
+    limit?: number,
+    sortBy?: { field: string; direction: "asc" | "desc" },
+    offset?: number,
+  ): Promise<TableItem[]> {
+    // ensure schema exists
+    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] as CoList<CoMap> | undefined;
+
+    if (!list) {
+      return [];
+    }
+
+    return this.filterSortPaginateList(list, where, limit, sortBy, offset);
+  }
+
+  async update(
+    model: string,
+    where: CleanedWhere[],
+    update: Record<string, any>,
+  ): Promise<TableItem[]> {
+    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 as Record<string, any>,
+      )) {
+        node.$jazz.set(key, value);
+      }
+    }
+
+    return nodes;
+  }
+
+  async deleteValue(model: string, where: CleanedWhere[]): Promise<number> {
+    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] as unknown as CoList<CoMap>;
+
+    for (const toBeDeleted of items) {
+      // Get entries without trigger the shallow load
+      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: string,
+    where: CleanedWhere[] | undefined,
+  ): Promise<number> {
+    return this.findMany(model, where).then((values) => values.length);
+  }
+
+  protected getSchema(model: string) {
+    const schema = this.databaseSchema.shape.tables.shape[model]?.element;
+    if (!schema) {
+      throw new Error(`Schema for model "${model}" not found`);
+    }
+    return schema;
+  }
+
+  protected filterSortPaginateList<T extends TableItem>(
+    list: CoList<CoMap | null>,
+    where: CleanedWhere[] | undefined,
+    limit?: number,
+    sortBy?: { field: string; direction: "asc" | "desc" },
+    offset?: number,
+  ): T[] {
+    // ignore nullable values and soft deleted items
+    return [
+      list.filter(
+        (item) => item !== null && item.$jazz.raw.get("_deleted") !== true,
+      ),
+    ]
+      .map((list) => filterListByWhere(list, where))
+      .map((list) => sortListByField(list, sortBy))
+      .map((list) => paginateList(list, limit, offset))
+      .at(0)! as T[];
+  }
+}

package/src/better-auth/database-adapter/repository/index.ts

@@ -0,0 +1,5 @@
+export * from "./generic.js";
+export * from "./user.js";
+export * from "./session.js";
+export * from "./verification.js";
+export * from "./account.js";

package/src/better-auth/database-adapter/repository/session.ts

@@ -0,0 +1,190 @@
+import { BetterAuthDbSchema } from "better-auth/db";
+import { CleanedWhere } from "better-auth/adapters";
+import { co, Account } from "jazz-tools";
+import { JazzRepository } from "./generic";
+import { UserRepository } from "./user";
+import {
+  containWhereByField,
+  extractWhereByField,
+  filterListByWhere,
+  isWhereBySingleField,
+} from "../utils";
+import type { Database, TableItem } from "../schema";
+
+type UserSchema = co.Map<{
+  sessions: co.List<co.Map<any>>;
+}>;
+
+export class SessionRepository extends JazzRepository {
+  protected userRepository: UserRepository;
+
+  constructor(
+    databaseSchema: Database,
+    databaseRoot: co.loaded<Database, { group: true }>,
+    worker: Account,
+    betterAuthSchema: BetterAuthDbSchema = {},
+    ensureSync: boolean = 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: string,
+    data: Record<string, any>,
+    uniqueId?: string,
+  ): Promise<TableItem> {
+    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: string,
+    where: CleanedWhere[] | undefined,
+    limit?: number,
+    sortBy?: { field: string; direction: "asc" | "desc" },
+    offset?: number,
+  ): Promise<TableItem[]> {
+    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 as string,
+          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: string, where: CleanedWhere[]): Promise<number> {
+    const items = await this.findMany(model, where);
+    if (items.length === 0) {
+      return 0;
+    }
+
+    const userId = items[0]!.userId;
+
+    return this.deleteSession(userId, items);
+  }
+
+  private async deleteSession(
+    userId: string,
+    items: TableItem[],
+  ): Promise<number> {
+    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) {
+      // Get entries without trigger the shallow load
+      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;
+  }
+}