jazz-tools 0.18.15 → 0.18.17

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

@@ -0,0 +1,158 @@
+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";
+
+const EmailIndex = co.map({ user: z.string().nullable() });
+
+export class UserRepository extends JazzRepository {
+  /**
+   * Custom logic:
+   * - sessions are stored inside the user object
+   * - keep sync email index
+   */
+  async create(
+    model: string,
+    data: Record<string, any>,
+    uniqueId?: string,
+  ): Promise<TableItem> {
+    const SessionListSchema = this.databaseSchema.shape.tables.shape.session;
+
+    if (!SessionListSchema) {
+      throw new Error("Session list schema not found");
+    }
+
+    const userEmail = data[this.getEmailProperty()] as string;
+
+    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: string,
+    where: CleanedWhere[] | undefined,
+    limit?: number,
+    sortBy?: { field: string; direction: "asc" | "desc" },
+    offset?: number,
+  ): Promise<TableItem[]> {
+    if (isWhereBySingleField("email", where)) {
+      return this.findByEmail(where[0].value as string);
+    }
+
+    return super.findMany(model, where, limit, sortBy, offset);
+  }
+
+  private getEmailProperty(): string {
+    return this.betterAuthSchema.user?.fields.email?.fieldName || "email";
+  }
+
+  private async findByEmail(email: string): Promise<TableItem[]> {
+    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((user) => (user ? [user] : []));
+  }
+
+  /**
+   * Custom logic:
+   * - if the email is changed, update the email index
+   */
+  async update(
+    model: string,
+    where: CleanedWhere[],
+    update: Record<string, any>,
+  ): Promise<TableItem[]> {
+    const nodes = await this.findMany(model, where);
+    if (nodes.length === 0) {
+      return [];
+    }
+
+    const newEmail = (update as Record<string, any>)[this.getEmailProperty()] as
+      | string
+      | undefined;
+
+    for (const node of nodes) {
+      const oldEmail = node.$jazz.raw.get(this.getEmailProperty()) as
+        | string
+        | undefined;
+      for (const [key, value] of Object.entries(
+        update as Record<string, any>,
+      )) {
+        node.$jazz.set(key, value);
+      }
+
+      // if the email is changed, update the email index
+      if (
+        oldEmail !== newEmail &&
+        oldEmail !== undefined &&
+        newEmail !== undefined
+      ) {
+        await this.updateEmailIndex(oldEmail, null);
+        await this.updateEmailIndex(newEmail, node.$jazz.id);
+      }
+    }
+
+    return nodes;
+  }
+
+  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 email = node.$jazz.raw.get(this.getEmailProperty()) as
+        | string
+        | undefined;
+      if (email) {
+        await this.updateEmailIndex(email, null);
+      }
+    }
+
+    return deleted;
+  }
+
+  private async loadEmailIndex(email: string) {
+    const emailIndex = await EmailIndex.loadUnique(email, this.owner.$jazz.id, {
+      loadAs: this.worker,
+    });
+
+    return emailIndex;
+  }
+
+  private async updateEmailIndex(email: string, userId: string | null) {
+    await EmailIndex.upsertUnique({
+      value: {
+        user: userId,
+      },
+      unique: email,
+      owner: this.owner,
+    });
+  }
+}

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

@@ -0,0 +1,37 @@
+import { CleanedWhere } from "better-auth/adapters";
+import { JazzRepository } from "./generic";
+import { isWhereBySingleField } from "../utils";
+import type { TableItem } from "../schema";
+
+export class VerificationRepository extends JazzRepository {
+  /**
+   * Custom logic: property identifier is used as uniqueId
+   */
+  async create(
+    model: string,
+    data: Record<string, any>,
+    uniqueId?: string,
+  ): Promise<TableItem> {
+    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: string,
+    where: CleanedWhere[] | undefined,
+    limit?: number,
+    sortBy?: { field: string; direction: "asc" | "desc" },
+    offset?: number,
+  ): Promise<TableItem[]> {
+    if (isWhereBySingleField("identifier", where)) {
+      return this.findByUnique(model, where).then((node) =>
+        node ? [node] : [],
+      );
+    }
+
+    return super.findMany(model, where, limit, sortBy, offset);
+  }
+}

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

@@ -0,0 +1,222 @@
+import { BetterAuthDbSchema, FieldAttribute } from "better-auth/db";
+import { Group, co, z } from "jazz-tools";
+
+type TableRow = co.Map<any>;
+export type TableItem = co.loaded<TableRow>;
+
+type Table = co.List<TableRow>;
+export type Database = co.Map<{
+  group: typeof Group;
+  tables: co.Map<{
+    [key: string]: Table;
+  }>;
+}>;
+
+type WorkerAccount = co.Account<{
+  profile: co.Profile;
+  root: co.Map<any>;
+}>;
+
+type JazzSchema = {
+  WorkerAccount: WorkerAccount;
+  DatabaseRoot: Database;
+  betterAuthSchema: BetterAuthDbSchema;
+  loadDatabase: (
+    account: co.loaded<co.Account>,
+    options?: Parameters<Database["loadUnique"]>[2],
+  ) => Promise<co.loaded<Database, { group: true }>>;
+};
+
+const DATABASE_ROOT_ID = "better-auth-root";
+
+export function createJazzSchema(schema: BetterAuthDbSchema): JazzSchema {
+  const tablesSchema = generateSchemaFromBetterAuthSchema(schema);
+
+  const DatabaseRoot: Database = co.map({
+    group: Group,
+    tables: co.map(tablesSchema),
+  });
+
+  const WorkerAccount: WorkerAccount = co
+    .account({
+      profile: co.profile(),
+      root: co.map({}),
+    })
+    .withMigration(async (account) => {
+      const dbRoot = await DatabaseRoot.loadUnique(
+        DATABASE_ROOT_ID,
+        account.$jazz.id,
+        {
+          resolve: {
+            group: true,
+            tables: true,
+          },
+          loadAs: account,
+        },
+      );
+
+      if (!dbRoot) {
+        // Create a group for the first time
+        // it will be the owner of the all tables and data
+        const adminGroup = Group.create({ owner: account });
+        await DatabaseRoot.upsertUnique({
+          value: {
+            group: adminGroup,
+            // create empty tables for each model
+            tables: co
+              .map(tablesSchema)
+              .create(
+                Object.fromEntries(
+                  Object.entries(tablesSchema).map(([key, value]) => [
+                    key,
+                    value.create([], adminGroup),
+                  ]),
+                ),
+                adminGroup,
+              ),
+          },
+          unique: DATABASE_ROOT_ID,
+          owner: account,
+        });
+      } else {
+        // partial migrations
+        for (const [key, value] of Object.entries(
+          DatabaseRoot.shape.tables.shape,
+        )) {
+          if (dbRoot.tables[key] === undefined) {
+            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,
+        },
+      )) as co.loaded<Database, { group: true }>;
+
+      if (!db) {
+        throw new Error("Database not found");
+      }
+
+      return db;
+    },
+  };
+}
+
+type ZodPrimitiveSchema =
+  | z.z.ZodString
+  | z.z.ZodNumber
+  | z.z.ZodBoolean
+  | z.z.ZodNull
+  | z.z.ZodDate
+  | z.z.ZodLiteral;
+type ZodOptionalPrimitiveSchema = z.z.ZodOptional<ZodPrimitiveSchema>;
+
+function generateSchemaFromBetterAuthSchema(schema: BetterAuthDbSchema) {
+  const tablesSchema: Record<string, Table> = {};
+
+  for (const [key, value] of Object.entries(schema)) {
+    const modelShape: Record<
+      string,
+      ZodPrimitiveSchema | ZodOptionalPrimitiveSchema
+    > = {
+      _deleted: z.boolean(),
+    };
+
+    for (const [fieldName, field] of Object.entries(value.fields)) {
+      modelShape[field.fieldName || fieldName] = convertFieldToCoValue(field);
+    }
+
+    const coMap = co.map(modelShape);
+    tablesSchema[key] = co.list(coMap);
+  }
+
+  if (tablesSchema["user"] && tablesSchema["session"]) {
+    tablesSchema["user"] = co.list(
+      co
+        .map({
+          ...tablesSchema["user"].element.shape,
+          sessions: tablesSchema["session"],
+        })
+        .withMigration((user) => {
+          if (user.sessions === undefined) {
+            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: FieldAttribute) {
+  let zodType: ZodPrimitiveSchema | ZodOptionalPrimitiveSchema;
+
+  switch (field.type) {
+    case "string":
+      zodType = z.string();
+      break;
+    case "number":
+      zodType = z.number();
+      break;
+    case "boolean":
+      zodType = z.boolean();
+      break;
+    case "date":
+      zodType = z.date();
+      break;
+    default:
+      throw new Error(`Unsupported field type: ${field.type}`);
+  }
+
+  if (field.required === false) {
+    zodType = zodType.optional();
+  }
+
+  return zodType;
+}
+
+export function tableItem2Record(
+  tableItem: TableItem | null | undefined,
+): Record<string, any> | null | undefined {
+  if (!tableItem) {
+    return tableItem;
+  }
+
+  // tableItem.toJSON() transforms Date objects to ISO strings
+  // by returning ...rest, we keep the objects
+  const { $jazz, ...rest } = tableItem;
+  return {
+    ...rest,
+    id: $jazz.id,
+  };
+}