jazz-tools 0.18.15 → 0.18.16

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

@@ -0,0 +1,228 @@
+import { type AdapterDebugLogs, createAdapter } from "better-auth/adapters";
+import type { Account } from "jazz-tools";
+import { startWorker } from "jazz-tools/worker";
+import {
+  JazzRepository,
+  UserRepository,
+  SessionRepository,
+  VerificationRepository,
+  AccountRepository,
+} from "./repository";
+import { createJazzSchema, tableItem2Record } from "./schema.js";
+
+export interface JazzAdapterConfig {
+  /**
+   * Helps you debug issues with the adapter.
+   */
+  debugLogs?: AdapterDebugLogs;
+  /**
+   * The sync server to use.
+   */
+  syncServer: string;
+  /**
+   * The worker account ID to use.
+   */
+  accountID: string;
+  /**
+   * The worker account secret to use.
+   */
+  accountSecret: string;
+}
+
+/**
+ * Creates a Better Auth database adapter that integrates with Jazz framework.
+ *
+ * This adapter provides a seamless integration between Better Auth and Jazz,
+ * allowing you to use Jazz as database for for Better Auth's authentication system.
+ *
+ * @param config - Configuration object for the Jazz Better Auth adapter
+ * @param config.syncServer - The Jazz sync server URL to connect to (e.g., "wss://your-sync-server.com")
+ * @param config.accountID - The worker account ID for the Jazz worker that will handle auth operations
+ * @param config.accountSecret - The worker account secret for authenticating with the Jazz sync server
+ * @param config.debugLogs - Optional debug logging configuration to help troubleshoot adapter issues
+ *
+ * @returns A Better Auth adapter instance configured to work with Jazz
+ *
+ * @example
+ * ```typescript
+ * import { JazzBetterAuthDatabaseAdapter } from "jazz-tools/better-auth/database-adapter";
+ * import { createAuth } from "better-auth";
+ *
+ * const auth = createAuth({
+ *   adapter: JazzBetterAuthDatabaseAdapter({
+ *     syncServer: "wss://your-jazz-sync-server.com",
+ *     accountID: "auth-worker-account-id",
+ *     accountSecret: "your-worker-account-secret",
+ *   }),
+ *   // ... other auth configuration
+ * });
+ * ```
+ */
+export const JazzBetterAuthDatabaseAdapter = (
+  config: JazzAdapterConfig,
+): ReturnType<typeof createAdapter> =>
+  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: Account | undefined = undefined;
+
+      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: string,
+        ensureSync: boolean = false,
+      ): Promise<JazzRepository> {
+        let Repository: typeof JazzRepository | undefined = undefined;
+        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 worker = await getWorker();
+        const database = await JazzSchema.loadDatabase(worker);
+
+        const repository = new Repository(
+          JazzSchema.DatabaseRoot,
+          database,
+          worker,
+          schema,
+          ensureSync,
+        );
+
+        return repository;
+      }
+
+      return {
+        create: async ({ data, model, select }): Promise<any> => {
+          // console.log("create", { 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 }): Promise<any> => {
+          // console.log("update", { model, where, update });
+          const repository = await initRepository(model, true);
+
+          const updated = await repository.update(
+            model,
+            where,
+            update as Record<string, any>,
+          );
+
+          if (updated.length === 0) {
+            return null;
+          }
+
+          await repository.ensureSync();
+
+          return tableItem2Record(updated[0]!);
+        },
+        updateMany: async ({ model, where, update }) => {
+          // console.log("updateMany", { 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 }) => {
+          // console.log("delete", { model, where });
+          const repository = await initRepository(model, true);
+
+          await repository.deleteValue(model, where);
+
+          await repository.ensureSync();
+        },
+        findOne: async ({ model, where }): Promise<any> => {
+          // console.log("findOne", { model, where });
+          const repository = await initRepository(model);
+
+          const item = await repository.findOne(model, where);
+
+          return tableItem2Record(item);
+        },
+        findMany: async ({
+          model,
+          where,
+          limit,
+          sortBy,
+          offset,
+        }): Promise<any[]> => {
+          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 }) => {
+          // console.log("count", { model, where });
+          const repository = await initRepository(model);
+
+          return repository.count(model, where);
+        },
+      };
+    },
+  });

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";