@datar-platform/better-auth-dynamodb 0.1.0-alpha.0 → 0.1.0

package/dist/index.js

@@ -1,15 +1,625 @@
-/**
- * @datar-platform/better-auth-dynamodb
- *
- * A generic DynamoDB adapter for Better Auth. Use the built-in single-table
- * store, or bring your own by implementing {@link DynamoStore}.
+// src/adapter.ts
+import { createAdapterFactory } from "better-auth/adapters";
+
+// src/pagination.ts
+async function drainPages(fetch) {
+  const out = [];
+  let cursor = void 0;
+  do {
+    const page = await fetch(cursor);
+    out.push(...page.items);
+    cursor = page.cursor;
+  } while (cursor);
+  return out;
+}
+function matchOne(item, w) {
+  const actual = item[w.field];
+  const expected = w.value;
+  switch (w.operator) {
+    case "eq":
+      return actual === expected;
+    case "ne":
+      return actual !== expected;
+    case "lt":
+      return actual < expected;
+    case "lte":
+      return actual <= expected;
+    case "gt":
+      return actual > expected;
+    case "gte":
+      return actual >= expected;
+    case "in":
+      return Array.isArray(expected) && expected.includes(actual);
+    case "not_in":
+      return Array.isArray(expected) && !expected.includes(actual);
+    case "contains":
+      return String(actual).includes(String(expected));
+    case "starts_with":
+      return String(actual).startsWith(String(expected));
+    case "ends_with":
+      return String(actual).endsWith(String(expected));
+    default:
+      return actual === expected;
+  }
+}
+function matchesResidual(item, residual) {
+  const andOk = residual.filter((w) => w.connector !== "OR").every((w) => matchOne(item, w));
+  if (!andOk) return false;
+  const or = residual.filter((w) => w.connector === "OR");
+  return or.length === 0 || or.some((w) => matchOne(item, w));
+}
+function applySort(items, sortBy) {
+  if (!sortBy) return items;
+  const { field, direction } = sortBy;
+  const dir = direction === "asc" ? 1 : -1;
+  return [...items].sort((a, b) => {
+    if (a[field] < b[field]) return -dir;
+    if (a[field] > b[field]) return dir;
+    return 0;
+  });
+}
+function applyWindow(items, offset, limit) {
+  let out = items;
+  if (offset && offset > 0) out = out.slice(offset);
+  if (limit && limit > 0) out = out.slice(0, limit);
+  return out;
+}
+
+// src/planner.ts
+function isKeyable(w) {
+  return w.operator === "eq" && w.connector === "AND" && w.value != null;
+}
+function planQuery(model, where, indexMap) {
+  const eqByField = /* @__PURE__ */ new Map();
+  for (const w of where) {
+    if (isKeyable(w) && !eqByField.has(w.field)) eqByField.set(w.field, w);
+  }
+  const idClause = eqByField.get("id");
+  if (idClause) {
+    return {
+      kind: "byId",
+      id: String(idClause.value),
+      residual: where.filter((w) => w !== idClause)
+    };
+  }
+  const patterns = indexMap[model] ?? [];
+  for (const pattern of patterns) {
+    if (!pattern.pk.every((f) => eqByField.has(f))) continue;
+    const key = {};
+    const consumed = /* @__PURE__ */ new Set();
+    for (const f of pattern.pk) {
+      const clause = eqByField.get(f);
+      key[f] = clause.value;
+      consumed.add(clause);
+    }
+    for (const f of pattern.sk ?? []) {
+      const clause = eqByField.get(f);
+      if (!clause) break;
+      key[f] = clause.value;
+      consumed.add(clause);
+    }
+    return {
+      kind: "index",
+      index: pattern.index,
+      key,
+      residual: where.filter((w) => !consumed.has(w))
+    };
+  }
+  return { kind: "listByType", residual: where };
+}
+
+// src/stores/default/derive-index-map.ts
+function lookupIndexName(field) {
+  return `by_${field}`;
+}
+function deriveIndexMap(schema) {
+  const map = {};
+  for (const [model, table] of Object.entries(schema)) {
+    const patterns = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = (field) => {
+      if (field === "id" || seen.has(field)) return;
+      seen.add(field);
+      patterns.push({ index: lookupIndexName(field), pk: [field] });
+    };
+    for (const [field, attr] of Object.entries(table.fields)) {
+      if (attr.unique) add(field);
+    }
+    for (const [field, attr] of Object.entries(table.fields)) {
+      if (attr.references) add(field);
+    }
+    for (const [field, attr] of Object.entries(table.fields)) {
+      if (attr.index) add(field);
+    }
+    if (patterns.length > 0) map[model] = patterns;
+  }
+  return map;
+}
+
+// src/stores/default/single-table-store.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import {
+  DeleteCommand,
+  DynamoDBDocumentClient,
+  GetCommand,
+  PutCommand,
+  QueryCommand
+} from "@aws-sdk/lib-dynamodb";
+
+// src/stores/default/key-codec.ts
+var PK = "__ba_pk";
+var SK = "__ba_sk";
+var TYPE_PK = "__ba_tpk";
+var TYPE_SK = "__ba_tsk";
+var TYPE_INDEX = "byType";
+var SK_CONST = "#";
+var RESERVED_PREFIX = "__ba_";
+var gsiName = (slot) => `lookup${slot}`;
+var gsiPk = (slot) => `__ba_g${slot}pk`;
+var gsiSk = (slot) => `__ba_g${slot}sk`;
+var enc = (v) => String(v);
+var joinValues = (values) => values.map(enc).join("#");
+function assignSlots(indexMap) {
+  const slots = {};
+  let maxSlots = 0;
+  for (const [model, patterns] of Object.entries(indexMap)) {
+    const modelSlots = {};
+    patterns.forEach((pattern, i) => {
+      modelSlots[pattern.index] = i + 1;
+    });
+    slots[model] = modelSlots;
+    maxSlots = Math.max(maxSlots, patterns.length);
+  }
+  return { slots, maxSlots };
+}
+var primaryKey = (model, id) => ({
+  [PK]: `${model}#${id}`,
+  [SK]: SK_CONST
+});
+var lookupPkValue = (model, index, values) => `${model}#${index}#${joinValues(values)}`;
+function encodeKeys(model, item, indexMap, assignment) {
+  const id = String(item.id);
+  const keys = {
+    ...primaryKey(model, id),
+    [TYPE_PK]: model,
+    [TYPE_SK]: `${enc(item.createdAt ?? "")}#${id}`
+  };
+  for (const pattern of indexMap[model] ?? []) {
+    const pkValues = pattern.pk.map((f) => item[f]);
+    if (pkValues.some((v) => v == null)) continue;
+    const slot = assignment.slots[model]?.[pattern.index];
+    if (!slot) continue;
+    keys[gsiPk(slot)] = lookupPkValue(model, pattern.index, pkValues);
+    const skValues = (pattern.sk ?? []).map((f) => item[f]);
+    keys[gsiSk(slot)] = skValues.some((v) => v == null) ? `${id}` : `${joinValues(skValues)}#${id}`;
+  }
+  return keys;
+}
+function encodeLookupQuery(model, index, key, indexMap, assignment) {
+  const slot = assignment.slots[model]?.[index];
+  if (!slot) {
+    throw new Error(
+      `No physical slot for index "${index}" on model "${model}". Ensure the index is present in the adapter's index map.`
+    );
+  }
+  const pattern = (indexMap[model] ?? []).find((p) => p.index === index);
+  const pkValues = pattern.pk.map((f) => key[f]);
+  const skPresent = (pattern.sk ?? []).map((f) => key[f]).filter((v) => v != null);
+  return {
+    indexName: gsiName(slot),
+    pkAttr: gsiPk(slot),
+    pkValue: lookupPkValue(model, index, pkValues),
+    skAttr: gsiSk(slot),
+    skPrefix: skPresent.length > 0 ? `${joinValues(skPresent)}#` : void 0
+  };
+}
+function stripReserved(item) {
+  if (!item) return null;
+  const clean = {};
+  for (const [k, v] of Object.entries(item)) {
+    if (!k.startsWith(RESERVED_PREFIX)) clean[k] = v;
+  }
+  return clean;
+}
+
+// src/stores/default/schema.ts
+import {
+  CreateTableCommand,
+  ResourceInUseException,
+  waitUntilTableExists
+} from "@aws-sdk/client-dynamodb";
+function buildTableDefinition(tableName, lookupSlots) {
+  const attr = (name) => ({
+    AttributeName: name,
+    AttributeType: "S"
+  });
+  const attributeDefinitions = [
+    attr(PK),
+    attr(SK),
+    attr(TYPE_PK),
+    attr(TYPE_SK)
+  ];
+  const globalSecondaryIndexes = [
+    {
+      IndexName: TYPE_INDEX,
+      KeySchema: [
+        { AttributeName: TYPE_PK, KeyType: "HASH" },
+        { AttributeName: TYPE_SK, KeyType: "RANGE" }
+      ],
+      Projection: { ProjectionType: "ALL" }
+    }
+  ];
+  for (let slot = 1; slot <= lookupSlots; slot++) {
+    attributeDefinitions.push(attr(gsiPk(slot)), attr(gsiSk(slot)));
+    globalSecondaryIndexes.push({
+      IndexName: gsiName(slot),
+      KeySchema: [
+        { AttributeName: gsiPk(slot), KeyType: "HASH" },
+        { AttributeName: gsiSk(slot), KeyType: "RANGE" }
+      ],
+      Projection: { ProjectionType: "ALL" }
+    });
+  }
+  return {
+    TableName: tableName,
+    BillingMode: "PAY_PER_REQUEST",
+    KeySchema: [
+      { AttributeName: PK, KeyType: "HASH" },
+      { AttributeName: SK, KeyType: "RANGE" }
+    ],
+    AttributeDefinitions: attributeDefinitions,
+    GlobalSecondaryIndexes: globalSecondaryIndexes
+  };
+}
+async function ensureSchema(opts) {
+  const input = buildTableDefinition(opts.tableName, opts.lookupSlots);
+  try {
+    await opts.client.send(new CreateTableCommand(input));
+  } catch (error) {
+    if (!(error instanceof ResourceInUseException)) throw error;
+  }
+  await waitUntilTableExists(
+    { client: opts.client, maxWaitTime: 60 },
+    { TableName: opts.tableName }
+  );
+}
+function generateSchemaFile(opts) {
+  const table = buildTableDefinition(opts.tableName, opts.lookupSlots);
+  const template = {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Resources: {
+      BetterAuthTable: { Type: "AWS::DynamoDB::Table", Properties: table }
+    }
+  };
+  const code = `/**
+ * Auto-generated DynamoDB CloudFormation template for @datar-platform/better-auth-dynamodb.
+ * Table: ${opts.tableName} \u2014 ${opts.lookupSlots} lookup GSI(s) + 1 byType GSI.
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-table.html
  */
-export { dynamoAdapter } from "./adapter.js";
-export { planQuery } from "./planner.js";
-export { matchesResidual } from "./pagination.js";
-// Built-in single-table store (opt-in for advanced wiring / tests).
-export { createSingleTableStore } from "./stores/default/single-table-store.js";
-export { deriveIndexMap } from "./stores/default/derive-index-map.js";
-export { buildTableDefinition, ensureSchema, generateSchemaFile, } from "./stores/default/schema.js";
-export { assignSlots } from "./stores/default/key-codec.js";
+export const dynamoDBSchema = ${JSON.stringify(template, null, 2)} as const;
+
+export default dynamoDBSchema;
+`;
+  return {
+    code,
+    path: opts.file ?? "dynamodb-cloudformation.ts",
+    overwrite: true
+  };
+}
+
+// src/stores/default/single-table-store.ts
+function createSingleTableStore(opts) {
+  const tableName = opts.tableName ?? process.env.DYNAMODB_TABLE_NAME ?? "better-auth";
+  const doc = opts.documentClient ?? DynamoDBDocumentClient.from(
+    new DynamoDBClient({
+      ...opts.region ? { region: opts.region } : {},
+      ...opts.endpoint ? { endpoint: opts.endpoint } : {}
+    }),
+    { marshallOptions: { removeUndefinedValues: true } }
+  );
+  const indexMap = opts.indexMap;
+  const assignment = assignSlots(indexMap);
+  const query = async (input, cursor, countOnly = false) => {
+    const res = await doc.send(
+      new QueryCommand({
+        TableName: tableName,
+        ExclusiveStartKey: cursor,
+        ...countOnly ? { Select: "COUNT" } : {},
+        ...input
+      })
+    );
+    return {
+      items: countOnly ? [] : (res.Items ?? []).map((i) => stripReserved(i)),
+      count: res.Count ?? 0,
+      cursor: res.LastEvaluatedKey
+    };
+  };
+  return {
+    async put(model, item) {
+      await doc.send(
+        new PutCommand({
+          TableName: tableName,
+          Item: { ...item, ...encodeKeys(model, item, indexMap, assignment) }
+        })
+      );
+      return item;
+    },
+    async getById(model, id) {
+      const res = await doc.send(
+        new GetCommand({ TableName: tableName, Key: primaryKey(model, id) })
+      );
+      return stripReserved(res.Item);
+    },
+    async update(model, id, patch) {
+      const res = await doc.send(
+        new GetCommand({ TableName: tableName, Key: primaryKey(model, id) })
+      );
+      const existing = stripReserved(res.Item);
+      if (!existing) return null;
+      const merged = { ...existing, ...patch };
+      await doc.send(
+        new PutCommand({
+          TableName: tableName,
+          Item: {
+            ...merged,
+            ...encodeKeys(model, merged, indexMap, assignment)
+          }
+        })
+      );
+      return merged;
+    },
+    async deleteById(model, id) {
+      await doc.send(
+        new DeleteCommand({ TableName: tableName, Key: primaryKey(model, id) })
+      );
+    },
+    async queryIndex({ model, index, key, cursor }) {
+      const lookup = encodeLookupQuery(model, index, key, indexMap, assignment);
+      const names = { "#pk": lookup.pkAttr };
+      const values = { ":pk": lookup.pkValue };
+      let condition = "#pk = :pk";
+      if (lookup.skPrefix) {
+        names["#sk"] = lookup.skAttr;
+        values[":skp"] = lookup.skPrefix;
+        condition += " AND begins_with(#sk, :skp)";
+      }
+      const { items, cursor: next } = await query(
+        {
+          IndexName: lookup.indexName,
+          KeyConditionExpression: condition,
+          ExpressionAttributeNames: names,
+          ExpressionAttributeValues: values
+        },
+        cursor
+      );
+      return { items, cursor: next };
+    },
+    async listByType({ model, cursor }) {
+      const { items, cursor: next } = await query(
+        {
+          IndexName: TYPE_INDEX,
+          KeyConditionExpression: "#tpk = :tpk",
+          ExpressionAttributeNames: { "#tpk": TYPE_PK },
+          ExpressionAttributeValues: { ":tpk": model }
+        },
+        cursor
+      );
+      return { items, cursor: next };
+    },
+    async count({ model, index, key }) {
+      let base;
+      if (index && key) {
+        const lookup = encodeLookupQuery(
+          model,
+          index,
+          key,
+          indexMap,
+          assignment
+        );
+        base = {
+          IndexName: lookup.indexName,
+          KeyConditionExpression: "#pk = :pk",
+          ExpressionAttributeNames: { "#pk": lookup.pkAttr },
+          ExpressionAttributeValues: { ":pk": lookup.pkValue }
+        };
+      } else {
+        base = {
+          IndexName: TYPE_INDEX,
+          KeyConditionExpression: "#tpk = :tpk",
+          ExpressionAttributeNames: { "#tpk": TYPE_PK },
+          ExpressionAttributeValues: { ":tpk": model }
+        };
+      }
+      let total = 0;
+      let cursor = void 0;
+      do {
+        const page = await query(base, cursor, true);
+        total += page.count;
+        cursor = page.cursor;
+      } while (cursor);
+      return total;
+    },
+    createSchema: ({ file }) => Promise.resolve(
+      generateSchemaFile({
+        tableName,
+        lookupSlots: assignment.maxSlots,
+        file
+      })
+    )
+  };
+}
+
+// src/adapter.ts
+var dynamoAdapter = (config = {}) => {
+  return createAdapterFactory({
+    config: {
+      adapterId: "dynamodb",
+      adapterName: "DynamoDB",
+      // DynamoDB keys are strings; let Better Auth generate string ids.
+      supportsNumericIds: false,
+      // We serialize JSON ourselves via the SDK document client.
+      supportsJSON: true,
+      // No native Date type — stored as ISO strings (see transforms below).
+      supportsDates: false,
+      supportsBooleans: true,
+      usePlural: false,
+      debugLogs: config.debugLogs,
+      // Dates <-> ISO strings, since supportsDates is false.
+      customTransformInput: ({ data, fieldAttributes }) => fieldAttributes.type === "date" && data instanceof Date ? data.toISOString() : data,
+      customTransformOutput: ({ data, fieldAttributes }) => fieldAttributes.type === "date" && typeof data === "string" ? new Date(data) : data
+    },
+    adapter: ({ schema, debugLog, getDefaultModelName }) => {
+      const indexMap = config.indexMap ?? deriveIndexMap(schema);
+      const store = config.store ?? createSingleTableStore({
+        tableName: config.tableName,
+        region: config.region,
+        endpoint: config.endpoint,
+        indexMap
+      });
+      const queryAll = async (model, where) => {
+        const clauses = where ?? [];
+        const plan = planQuery(model, clauses, indexMap);
+        debugLog("queryAll", { model, plan: plan.kind });
+        let candidates;
+        if (plan.kind === "byId") {
+          const one = await store.getById(model, plan.id);
+          candidates = one ? [one] : [];
+        } else if (plan.kind === "index") {
+          candidates = await drainPages(
+            (cursor) => store.queryIndex({
+              model,
+              index: plan.index,
+              key: plan.key,
+              cursor
+            })
+          );
+        } else {
+          candidates = await drainPages(
+            (cursor) => store.listByType({ model, cursor })
+          );
+        }
+        return candidates.filter(
+          (item) => matchesResidual(item, plan.residual)
+        );
+      };
+      const resolveId = async (model, where) => {
+        const plan = planQuery(model, where, indexMap);
+        if (plan.kind === "byId") return plan.id;
+        const [first] = await queryAll(model, where);
+        return first ? String(first.id) : null;
+      };
+      return {
+        async create({
+          model,
+          data
+        }) {
+          const m = getDefaultModelName(model);
+          const created = await store.put(m, data);
+          return created;
+        },
+        async update({
+          model,
+          where,
+          update
+        }) {
+          const m = getDefaultModelName(model);
+          const id = await resolveId(m, where);
+          if (!id) return null;
+          const updated = await store.update(m, id, update);
+          return updated;
+        },
+        async updateMany({
+          model,
+          where,
+          update
+        }) {
+          const m = getDefaultModelName(model);
+          const items = await queryAll(m, where);
+          await runBatched(
+            items,
+            (item) => store.update(m, String(item.id), update)
+          );
+          return items.length;
+        },
+        async delete({
+          model,
+          where
+        }) {
+          const m = getDefaultModelName(model);
+          const id = await resolveId(m, where);
+          if (id) await store.deleteById(m, id);
+        },
+        async deleteMany({
+          model,
+          where
+        }) {
+          const m = getDefaultModelName(model);
+          const items = await queryAll(m, where);
+          await runBatched(
+            items,
+            (item) => store.deleteById(m, String(item.id))
+          );
+          return items.length;
+        },
+        async findOne({
+          model,
+          where
+        }) {
+          const m = getDefaultModelName(model);
+          const [first] = await queryAll(m, where);
+          return first ?? null;
+        },
+        async findMany({
+          model,
+          where,
+          limit,
+          sortBy,
+          offset
+        }) {
+          const m = getDefaultModelName(model);
+          const items = applyWindow(
+            applySort(await queryAll(m, where), sortBy),
+            offset,
+            limit
+          );
+          return items;
+        },
+        async count({
+          model,
+          where
+        }) {
+          const m = getDefaultModelName(model);
+          const clauses = where ?? [];
+          const plan = planQuery(m, clauses, indexMap);
+          if (plan.residual.length === 0 && store.count) {
+            const fast = await store.count(
+              plan.kind === "index" ? { model: m, index: plan.index, key: plan.key } : { model: m }
+            );
+            if (fast != null) return fast;
+          }
+          return (await queryAll(m, clauses)).length;
+        },
+        ...store.createSchema ? {
+          createSchema: (props) => store.createSchema(props)
+        } : {}
+      };
+    }
+  });
+};
+async function runBatched(items, op, chunkSize = 10) {
+  for (let i = 0; i < items.length; i += chunkSize) {
+    await Promise.all(items.slice(i, i + chunkSize).map(op));
+  }
+}
+export {
+  assignSlots,
+  buildTableDefinition,
+  createSingleTableStore,
+  deriveIndexMap,
+  dynamoAdapter,
+  ensureSchema,
+  generateSchemaFile,
+  matchesResidual,
+  planQuery
+};
 //# sourceMappingURL=index.js.map