@lupinum/better-convex-nuxt 0.8.0-beta.40

package/dist/runtime/convex-auth/adapter/query.js

@@ -0,0 +1,275 @@
+import { mergedStream, stream } from "convex-helpers/server/stream";
+import { getAuthFieldMetadata, getAuthModelMetadata } from "./metadata.js";
+function compareNullable(left, right) {
+  if (left === right) return 0;
+  if (left === null || left === void 0) return -1;
+  if (right === null || right === void 0) return 1;
+  if (typeof left === "number" && typeof right === "number") return left < right ? -1 : 1;
+  if (typeof left === "string" && typeof right === "string") return left < right ? -1 : 1;
+  if (typeof left === "boolean" && typeof right === "boolean") return left === false ? -1 : 1;
+  return String(left).localeCompare(String(right));
+}
+export function matchesAuthWhere(doc, where = []) {
+  if (where.length === 0) return true;
+  const evaluate = (clause) => {
+    const actual = doc[clause.field];
+    const expected = clause.value;
+    const insensitive = clause.mode === "insensitive";
+    const normalize = (value) => insensitive && typeof value === "string" ? value.toLocaleLowerCase() : value;
+    const normalizedActual = normalize(actual);
+    const normalizedExpected = Array.isArray(expected) ? expected.map((value) => normalize(value)) : normalize(expected);
+    switch (clause.operator ?? "eq") {
+      case "eq":
+        return expected === null ? actual === null || actual === void 0 : normalizedActual === normalizedExpected;
+      case "ne":
+        return normalizedActual !== normalizedExpected;
+      case "lt":
+        return expected !== null && compareNullable(actual, expected) < 0;
+      case "lte":
+        return expected !== null && compareNullable(actual, expected) <= 0;
+      case "gt":
+        return expected !== null && compareNullable(actual, expected) > 0;
+      case "gte":
+        return expected !== null && compareNullable(actual, expected) >= 0;
+      case "in":
+        return Array.isArray(normalizedExpected) && normalizedExpected.includes(normalizedActual);
+      case "not_in":
+        return Array.isArray(normalizedExpected) && !normalizedExpected.includes(normalizedActual);
+      case "contains":
+        return typeof normalizedActual === "string" && typeof normalizedExpected === "string" && normalizedActual.includes(normalizedExpected);
+      case "starts_with":
+        return typeof normalizedActual === "string" && typeof normalizedExpected === "string" && normalizedActual.startsWith(normalizedExpected);
+      case "ends_with":
+        return typeof normalizedActual === "string" && typeof normalizedExpected === "string" && normalizedActual.endsWith(normalizedExpected);
+    }
+  };
+  let result = evaluate(where[0]);
+  for (const clause of where.slice(1)) {
+    const clauseResult = evaluate(clause);
+    result = clause.connector === "OR" ? result || clauseResult : result && clauseResult;
+  }
+  return result;
+}
+export function validateAuthReadArgs(metadata, args) {
+  const model = getAuthModelMetadata(metadata, args.model);
+  if (args.offset !== void 0 && args.offset !== 0) throw new Error("AUTH_OFFSET_UNSUPPORTED");
+  for (const clause of args.where ?? []) {
+    const field = getAuthFieldMetadata(metadata, args.model, clause.field);
+    if (clause.mode === "insensitive" && typeof clause.value !== "string" && !(Array.isArray(clause.value) && clause.value.every((value) => typeof value === "string"))) {
+      throw new Error(`AUTH_CASE_INSENSITIVE_VALUE_INVALID:${args.model}.${field.physicalName}`);
+    }
+    if ((clause.operator === "in" || clause.operator === "not_in") && !Array.isArray(clause.value)) {
+      throw new Error(`AUTH_ARRAY_OPERATOR_REQUIRES_ARRAY:${args.model}.${field.physicalName}`);
+    }
+  }
+  for (const fieldName of args.select ?? []) getAuthFieldMetadata(metadata, args.model, fieldName);
+  if (args.sortBy) {
+    const field = getAuthFieldMetadata(metadata, args.model, args.sortBy.field);
+    if (!field.sortable && field.physicalName !== "createdAt") {
+      throw new Error(`AUTH_FIELD_NOT_SORTABLE:${model.physicalName}.${field.physicalName}`);
+    }
+  }
+}
+const AUTH_IN_FANOUT_LIMIT = 64;
+function chooseExactIndexedIn(model, where, sortBy) {
+  if (sortBy || where.some((clause2) => clause2.connector === "OR" || clause2.mode === "insensitive")) {
+    return void 0;
+  }
+  const clauses = where.filter((clause2) => clause2.operator === "in");
+  if (clauses.length !== 1) return void 0;
+  const clause = clauses[0];
+  if (!Array.isArray(clause.value)) return void 0;
+  const index = model.indexes.find(
+    (candidate) => candidate.fields.length === 1 && candidate.fields[0] === clause.field
+  );
+  if (!index) return void 0;
+  if (clause.value.length > AUTH_IN_FANOUT_LIMIT) {
+    throw new Error("AUTH_IN_FANOUT_LIMIT_EXCEEDED");
+  }
+  return {
+    clause,
+    index
+  };
+}
+function planForIndex(index, where) {
+  const equality = [];
+  let range;
+  let prefix = 0;
+  for (const field of index.fields) {
+    const eq = where.find(
+      (clause) => clause.field === field && (clause.operator === void 0 || clause.operator === "eq")
+    );
+    if (eq) {
+      equality.push(eq);
+      prefix += 1;
+      continue;
+    }
+    range = where.find(
+      (clause) => clause.field === field && (clause.operator === "lt" || clause.operator === "lte" || clause.operator === "gt" || clause.operator === "gte")
+    );
+    if (range) prefix += 1;
+    break;
+  }
+  if (prefix === 0) return void 0;
+  return { index, equality, range, score: prefix * 10 + equality.length };
+}
+function chooseIndex(model, where) {
+  if (where.some((clause) => clause.connector === "OR" || clause.mode === "insensitive")) {
+    return void 0;
+  }
+  return model.indexes.map((index) => planForIndex(index, where)).filter((plan) => plan !== void 0).sort((left, right) => right.score - left.score)[0];
+}
+function planForSortIndex(index, where, sortField) {
+  if (index.fields.at(-1) !== sortField) return void 0;
+  const equality = [];
+  for (const field of index.fields.slice(0, -1)) {
+    const clause = where.find(
+      (candidate) => candidate.field === field && (candidate.operator === void 0 || candidate.operator === "eq")
+    );
+    if (!clause) return void 0;
+    equality.push(clause);
+  }
+  const range = where.find(
+    (clause) => clause.field === sortField && (clause.operator === "lt" || clause.operator === "lte" || clause.operator === "gt" || clause.operator === "gte")
+  );
+  return {
+    index,
+    equality,
+    range,
+    score: index.fields.length * 10 + equality.length
+  };
+}
+function chooseSortIndex(model, where, sortField) {
+  const filterOnly = where.some(
+    (clause) => clause.connector === "OR" || clause.mode === "insensitive"
+  );
+  return model.indexes.filter((index) => !filterOnly || index.fields.length === 1).map((index) => planForSortIndex(index, filterOnly ? [] : where, sortField)).filter((plan) => plan !== void 0).sort((left, right) => right.score - left.score)[0];
+}
+function applyIndexRange(builder, plan) {
+  let result = builder;
+  for (const clause of plan.equality) result = result.eq(clause.field, clause.value);
+  if (!plan.range) return result;
+  switch (plan.range.operator) {
+    case "lt":
+      return result.lt(plan.range.field, plan.range.value);
+    case "lte":
+      return result.lte(plan.range.field, plan.range.value);
+    case "gt":
+      return result.gt(plan.range.field, plan.range.value);
+    case "gte":
+      return result.gte(plan.range.field, plan.range.value);
+    default:
+      return result;
+  }
+}
+function createAuthQuery(ctx, schema, metadata, args) {
+  validateAuthReadArgs(metadata, args);
+  const model = getAuthModelMetadata(metadata, args.model);
+  const exactIndexedIn = chooseExactIndexedIn(model, args.where ?? [], args.sortBy);
+  if (exactIndexedIn && exactIndexedIn.clause.value.length > 0) {
+    const values = [...new Set(exactIndexedIn.clause.value)];
+    const streams = values.map(
+      (value) => stream(ctx.db, schema).query(args.model).withIndex(
+        exactIndexedIn.index.descriptor,
+        (builder) => builder.eq(exactIndexedIn.clause.field, value)
+      )
+    );
+    return mergedStream(streams, ["_creationTime"]).filterWith(
+      async (doc) => matchesAuthWhere(doc, args.where ?? [])
+    );
+  }
+  const plan = chooseIndex(model, args.where ?? []);
+  let query = stream(ctx.db, schema).query(args.model);
+  if (plan) {
+    query = query.withIndex(
+      plan.index.descriptor,
+      (builder) => applyIndexRange(builder, plan)
+    );
+  }
+  if (args.sortBy) {
+    const sortPlan = chooseSortIndex(model, args.where ?? [], args.sortBy.field);
+    if (!sortPlan) {
+      throw new Error(`AUTH_SORT_INDEX_MISSING:${args.model}.${args.sortBy.field}`);
+    }
+    query = stream(ctx.db, schema).query(args.model).withIndex(
+      sortPlan.index.descriptor,
+      (builder) => applyIndexRange(builder, sortPlan)
+    ).order(args.sortBy.direction);
+  }
+  return query.filterWith(
+    async (doc) => matchesAuthWhere(doc, args.where ?? [])
+  );
+}
+export function toBetterAuthDocument(doc, select) {
+  if (!doc) return null;
+  const clean = Object.fromEntries(
+    Object.entries(doc).filter(([field]) => field !== "_id" && field !== "_creationTime")
+  );
+  if (!select?.length) return clean;
+  return Object.fromEntries(
+    select.filter((field) => field in clean).map((field) => [field, clean[field]])
+  );
+}
+export async function paginateAuthRows(ctx, schema, metadata, args, paginationOpts) {
+  const result = await createAuthQuery(ctx, schema, metadata, args).paginate({
+    ...paginationOpts,
+    maximumRowsRead: Math.max((paginationOpts.numItems ?? 0) + 1, 200)
+  });
+  return {
+    ...result,
+    page: result.page.map((doc) => toBetterAuthDocument(doc, args.select))
+  };
+}
+export async function collectAuthRows(ctx, schema, metadata, args, maximum) {
+  if (maximum !== void 0 && (!Number.isSafeInteger(maximum) || maximum < 0)) {
+    throw new TypeError("AUTH_QUERY_LIMIT_INVALID");
+  }
+  const rows = [];
+  let cursor = null;
+  do {
+    const requested = maximum === void 0 ? 100 : Math.min(100, maximum + 1 - rows.length);
+    const page = await createAuthQuery(ctx, schema, metadata, args).paginate({
+      cursor,
+      numItems: requested,
+      maximumRowsRead: 200
+    });
+    rows.push(...page.page);
+    if (maximum !== void 0 && rows.length > maximum) {
+      throw new Error(`AUTH_QUERY_LIMIT_EXCEEDED:${maximum}`);
+    }
+    if (page.isDone) {
+      cursor = null;
+      continue;
+    }
+    if (typeof page.continueCursor !== "string" || page.continueCursor === cursor) {
+      throw new Error("AUTH_QUERY_PAGINATION_STALLED");
+    }
+    cursor = page.continueCursor;
+  } while (cursor !== null);
+  return rows;
+}
+export async function countAuthRows(ctx, schema, metadata, args) {
+  let count = 0;
+  let cursor = null;
+  while (true) {
+    const cursorBefore = cursor;
+    const page = await createAuthQuery(ctx, schema, metadata, args).paginate({
+      cursor,
+      numItems: 100,
+      maximumRowsRead: 200
+    });
+    count += page.page.length;
+    if (page.isDone) return count;
+    if (typeof page.continueCursor !== "string") {
+      throw new TypeError("AUTH_COUNT_PAGINATION_INVALID");
+    }
+    cursor = page.continueCursor;
+    if (cursor === cursorBefore && page.page.length === 0) {
+      throw new Error("AUTH_COUNT_PAGINATION_STALLED");
+    }
+  }
+}
+export async function findAuthRows(ctx, schema, metadata, args, maximum = 2) {
+  const rows = await collectAuthRows(ctx, schema, metadata, args, maximum);
+  return rows;
+}

package/dist/runtime/convex-auth/adapter/relationships.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaDefinition } from 'convex/server';
+import type { AuthSchemaMetadata } from './metadata.js';
+import { collectAuthRows } from './query.js';
+interface RelationshipTriggerHandles {
+    onDeleteHandle?: string;
+    onDeleteModels?: readonly string[];
+    onUpdateHandle?: string;
+    onUpdateModels?: readonly string[];
+}
+type TriggerRunner = (ctx: any, handle: string | undefined, payload: Record<string, unknown>) => Promise<void>;
+export declare function createAuthRelationshipEngine(input: {
+    schema: SchemaDefinition<any, any>;
+    metadata: AuthSchemaMetadata;
+    runTrigger: TriggerRunner;
+}): Readonly<{
+    applyDeletion: (ctx: any, roots: Record<string, unknown>[], rootModel: string, handles: RelationshipTriggerHandles) => Promise<void>;
+    assertTargets: (ctx: any, modelName: string, row: Record<string, unknown>, changedFields?: ReadonlySet<string>) => Promise<void>;
+    collectOperationRows: (ctx: any, args: Parameters<typeof collectAuthRows>[3]) => Promise<Record<string, unknown>[]>;
+}>;
+export {};

package/dist/runtime/convex-auth/adapter/relationships.js

@@ -0,0 +1,128 @@
+import { getAuthModelMetadata } from "./metadata.js";
+import { collectAuthRows, findAuthRows, toBetterAuthDocument } from "./query.js";
+const AUTH_BULK_OPERATION_LIMIT = 128;
+function rejectOversizedOperation() {
+  throw new Error("AUTH_BULK_OPERATION_LIMIT_EXCEEDED");
+}
+function plannedRow(model, row) {
+  return { key: `${model}:${String(row._id)}`, model, row };
+}
+export function createAuthRelationshipEngine(input) {
+  const { schema, metadata, runTrigger } = input;
+  const inboundByModel = /* @__PURE__ */ new Map();
+  for (const model of Object.values(metadata.models)) {
+    for (const field of Object.values(model.fields)) {
+      if (!field.reference) continue;
+      const inbound = inboundByModel.get(field.reference.model) ?? [];
+      inbound.push({ model: model.physicalName, field });
+      inboundByModel.set(field.reference.model, inbound);
+    }
+  }
+  async function assertTargets(ctx, modelName, row, changedFields) {
+    const model = getAuthModelMetadata(metadata, modelName);
+    for (const field of Object.values(model.fields)) {
+      if (!field.reference || changedFields && !changedFields.has(field.physicalName)) continue;
+      const value = row[field.physicalName];
+      if (value === null) continue;
+      const matches = await findAuthRows(
+        ctx,
+        schema,
+        metadata,
+        {
+          model: field.reference.model,
+          where: [{ field: field.reference.field, value }]
+        },
+        2
+      );
+      if (matches.length === 0) {
+        throw new Error(`AUTH_REFERENCE_TARGET_MISSING:${modelName}.${field.physicalName}`);
+      }
+      if (matches.length > 1) {
+        throw new Error(`AUTH_REFERENCE_TARGET_AMBIGUOUS:${modelName}.${field.physicalName}`);
+      }
+    }
+  }
+  async function findReferencingRows(ctx, parent, childModel, childField) {
+    const parentField = childField.reference.field;
+    return collectOperationRows(ctx, {
+      model: childModel,
+      where: [{ field: childField.physicalName, value: parent.row[parentField] }]
+    });
+  }
+  async function collectOperationRows(ctx, args) {
+    try {
+      return await collectAuthRows(ctx, schema, metadata, args, AUTH_BULK_OPERATION_LIMIT);
+    } catch (error) {
+      if (error instanceof Error && error.message === `AUTH_QUERY_LIMIT_EXCEEDED:${AUTH_BULK_OPERATION_LIMIT}`) {
+        rejectOversizedOperation();
+      }
+      throw error;
+    }
+  }
+  async function applyDeletion(ctx, roots, rootModel, handles) {
+    const visited = /* @__PURE__ */ new Set();
+    const deletionOrder = [];
+    const deleteTriggerModels = new Set(handles.onDeleteModels ?? []);
+    const updateTriggerModels = new Set(handles.onUpdateModels ?? []);
+    const collectCascade = async (candidate) => {
+      if (visited.has(candidate.key)) return;
+      if (visited.size === AUTH_BULK_OPERATION_LIMIT) rejectOversizedOperation();
+      visited.add(candidate.key);
+      for (const inbound of inboundByModel.get(candidate.model) ?? []) {
+        if (inbound.field.reference.onDelete !== "cascade") continue;
+        const children = await findReferencingRows(ctx, candidate, inbound.model, inbound.field);
+        for (const child of children) await collectCascade(plannedRow(inbound.model, child));
+      }
+      deletionOrder.push(candidate);
+    };
+    for (const root of roots) await collectCascade(plannedRow(rootModel, root));
+    const setNullPatches = /* @__PURE__ */ new Map();
+    for (const candidate of deletionOrder) {
+      for (const inbound of inboundByModel.get(candidate.model) ?? []) {
+        const policy = inbound.field.reference.onDelete;
+        if (policy === "cascade") continue;
+        const children = await findReferencingRows(ctx, candidate, inbound.model, inbound.field);
+        for (const child of children) {
+          const planned = plannedRow(inbound.model, child);
+          if (visited.has(planned.key)) continue;
+          if (policy === "restrict") {
+            throw new Error(
+              `AUTH_REFERENCE_DELETE_RESTRICTED:${candidate.model}.${inbound.field.reference.field}`
+            );
+          }
+          if (!inbound.field.nullable) {
+            throw new Error(
+              `AUTH_REFERENCE_SET_NULL_REQUIRED:${inbound.model}.${inbound.field.physicalName}`
+            );
+          }
+          const existing = setNullPatches.get(planned.key) ?? { planned, patch: {} };
+          if (!setNullPatches.has(planned.key) && visited.size + setNullPatches.size === AUTH_BULK_OPERATION_LIMIT) {
+            rejectOversizedOperation();
+          }
+          existing.patch[inbound.field.physicalName] = null;
+          setNullPatches.set(planned.key, existing);
+        }
+      }
+    }
+    for (const { planned, patch } of setNullPatches.values()) {
+      await ctx.db.patch(planned.model, planned.row._id, patch);
+      if (!handles.onUpdateHandle || !updateTriggerModels.has(planned.model)) continue;
+      const updated = await ctx.db.get(planned.model, planned.row._id);
+      if (!updated) throw new Error("AUTH_REFERENCE_SET_NULL_READBACK_FAILED");
+      await runTrigger(ctx, handles.onUpdateHandle, {
+        model: planned.model,
+        oldDoc: toBetterAuthDocument(planned.row),
+        newDoc: toBetterAuthDocument(updated)
+      });
+    }
+    for (const candidate of deletionOrder) {
+      await ctx.db.delete(candidate.model, candidate.row._id);
+      if (!handles.onDeleteHandle || !deleteTriggerModels.has(candidate.model)) continue;
+      await runTrigger(ctx, handles.onDeleteHandle, {
+        model: candidate.model,
+        doc: toBetterAuthDocument(candidate.row)
+      });
+    }
+  }
+  return Object.freeze({ applyDeletion, assertTargets, collectOperationRows });
+}

package/dist/runtime/convex-auth/component/_generated/api.js

@@ -0,0 +1,5 @@
+import { anyApi, componentsGeneric } from "convex/server";
+const fullApi = anyApi;
+export const api = anyApi;
+export const internal = anyApi;
+export const components = componentsGeneric();

package/dist/runtime/convex-auth/component/_generated/component.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `pnpm exec better-convex-nuxt-convex codegen --component-dir src/runtime/convex-auth/component`.
+ * @module
+ */
+import type { FunctionReference, PaginationOptions, PaginationResult } from 'convex/server';
+type AuthValue = string | number | boolean | string[] | number[] | null;
+type AuthWhere = {
+    connector?: 'AND' | 'OR';
+    field: string;
+    mode?: 'sensitive' | 'insensitive';
+    operator?: 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'in' | 'not_in' | 'ne' | 'contains' | 'starts_with' | 'ends_with';
+    value: AuthValue;
+};
+type AuthDocument = Record<string, AuthValue>;
+type TriggerArgs = {
+    onCreateHandle?: string;
+    onDeleteHandle?: string;
+    onUpdateHandle?: string;
+};
+type SigningKeyCandidate = {
+    alg: 'RS256';
+    crv: null;
+    id: string;
+    privateKey: string;
+    publicKey: string;
+};
+type SigningKeyRotationMetadata = {
+    createdAt: number;
+    newKid: string;
+    previousKids: string[];
+    previousVerifyUntil: number;
+    rotatedAt: number;
+};
+/** A utility for accepting the mounted Better Convex Nuxt auth component. */
+export type ComponentApi<Name extends string | undefined = string | undefined> = {
+    adapter: {
+        consumeOne: FunctionReference<'mutation', 'internal', {
+            model: string;
+            where: AuthWhere[];
+            onDeleteHandle?: string;
+            onDeleteModels?: string[];
+            onUpdateHandle?: string;
+            onUpdateModels?: string[];
+        }, AuthDocument | null, Name>;
+        count: FunctionReference<'query', 'internal', {
+            model: string;
+            where?: AuthWhere[];
+        }, number, Name>;
+        create: FunctionReference<'mutation', 'internal', {
+            data: Record<string, unknown>;
+            model: string;
+        } & TriggerArgs, AuthDocument, Name>;
+        deleteMany: FunctionReference<'mutation', 'internal', {
+            model: string;
+            where: AuthWhere[];
+            onDeleteHandle?: string;
+            onDeleteModels?: string[];
+            onUpdateHandle?: string;
+            onUpdateModels?: string[];
+        }, number, Name>;
+        deleteOne: FunctionReference<'mutation', 'internal', {
+            model: string;
+            where: AuthWhere[];
+            onDeleteHandle?: string;
+            onDeleteModels?: string[];
+            onUpdateHandle?: string;
+            onUpdateModels?: string[];
+        }, AuthDocument | null, Name>;
+        findMany: FunctionReference<'query', 'internal', {
+            join?: unknown;
+            limit?: number;
+            model: string;
+            offset?: number;
+            paginationOpts: PaginationOptions;
+            select?: string[];
+            sortBy?: {
+                direction: 'asc' | 'desc';
+                field: string;
+            };
+            where?: AuthWhere[];
+        }, PaginationResult<AuthDocument>, Name>;
+        findOne: FunctionReference<'query', 'internal', {
+            join?: unknown;
+            model: string;
+            select?: string[];
+            where?: AuthWhere[];
+        }, AuthDocument | null, Name>;
+        incrementOne: FunctionReference<'mutation', 'internal', {
+            increment: Record<string, number>;
+            model: string;
+            onUpdateHandle?: string;
+            set?: Record<string, unknown>;
+            where: AuthWhere[];
+        }, AuthDocument | null, Name>;
+        rotateSigningKey: FunctionReference<'mutation', 'internal', {
+            next: SigningKeyCandidate;
+        }, SigningKeyRotationMetadata, Name>;
+        updateMany: FunctionReference<'mutation', 'internal', {
+            model: string;
+            onUpdateHandle?: string;
+            update: Record<string, unknown>;
+            where: AuthWhere[];
+        }, number, Name>;
+        updateOne: FunctionReference<'mutation', 'internal', {
+            model: string;
+            onUpdateHandle?: string;
+            update: Record<string, unknown>;
+            where: AuthWhere[];
+        }, AuthDocument | null, Name>;
+    };
+};
+export {};

package/dist/runtime/convex-auth/component/_generated/server.js

@@ -0,0 +1,16 @@
+import {
+  actionGeneric,
+  httpActionGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+  mutationGeneric,
+  queryGeneric
+} from "convex/server";
+export const query = queryGeneric;
+export const internalQuery = internalQueryGeneric;
+export const mutation = mutationGeneric;
+export const internalMutation = internalMutationGeneric;
+export const action = actionGeneric;
+export const internalAction = internalActionGeneric;
+export const httpAction = httpActionGeneric;