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

package/dist/runtime/convex-auth/adapter/generate-schema.js

@@ -0,0 +1,332 @@
+import {
+  fingerprintAuthSchemaModels
+} from "./metadata.js";
+const explicitIndexes = {
+  invitation: [
+    { fields: ["email", "organizationId", "status"] },
+    { fields: ["organizationId", "status", "createdAt"] }
+  ],
+  member: [{ fields: ["organizationId", "userId"], unique: true }],
+  oauthConsent: [{ fields: ["clientId", "userId"] }],
+  rateLimit: [{ fields: ["key"] }],
+  session: [{ fields: ["expiresAt"] }, { fields: ["userId", "expiresAt"] }],
+  teamMember: [{ fields: ["teamId", "userId"], unique: true }],
+  verification: [
+    { fields: ["expiresAt"] },
+    { fields: ["identifier"] },
+    { fields: ["identifier", "createdAt"] }
+  ]
+};
+function physicalFieldName(logicalName, field) {
+  return field.fieldName ?? logicalName;
+}
+function fieldKind(field) {
+  const kind = field.type;
+  if (kind !== "string" && kind !== "number" && kind !== "boolean" && kind !== "date" && kind !== "json" && kind !== "string[]" && kind !== "number[]") {
+    throw new Error(`AUTH_SCHEMA_UNSUPPORTED_FIELD_TYPE:${String(field.type)}`);
+  }
+  return kind;
+}
+function validatorForKind(kind) {
+  switch (kind) {
+    case "string":
+    case "json":
+      return "v.string()";
+    case "number":
+    case "date":
+      return "v.number()";
+    case "boolean":
+      return "v.boolean()";
+    case "string[]":
+      return "v.array(v.string())";
+    case "number[]":
+      return "v.array(v.number())";
+  }
+}
+function descriptorFor(fields) {
+  if (fields.length === 0) throw new Error("AUTH_SCHEMA_EMPTY_INDEX");
+  return fields.join("_");
+}
+function buildIndexes(logicalModelName, fields, tableIndexes) {
+  const indexes = [];
+  const seenDescriptors = /* @__PURE__ */ new Set();
+  const indexesByFields = /* @__PURE__ */ new Map();
+  const add = (logicalFields, unique = false, name) => {
+    const physicalFields = logicalFields.map((logicalField) => {
+      const field = Object.values(fields).find(
+        (candidate) => candidate.logicalName === logicalField
+      );
+      if (!field)
+        throw new Error(`AUTH_SCHEMA_INDEX_UNKNOWN_FIELD:${logicalModelName}.${logicalField}`);
+      return field.physicalName;
+    });
+    const fieldKey = JSON.stringify(physicalFields);
+    const existing = indexesByFields.get(fieldKey);
+    if (existing) {
+      if (unique) existing.unique = true;
+      return;
+    }
+    const descriptor = name ?? descriptorFor(physicalFields);
+    if (seenDescriptors.has(descriptor)) {
+      throw new Error(`AUTH_SCHEMA_INDEX_NAME_COLLISION:${logicalModelName}.${descriptor}`);
+    }
+    seenDescriptors.add(descriptor);
+    const index = {
+      descriptor,
+      fields: physicalFields,
+      ...unique ? { unique: true } : {}
+    };
+    indexesByFields.set(fieldKey, index);
+    indexes.push(index);
+  };
+  add(["id"], true);
+  for (const declared of tableIndexes) {
+    add(declared.fields, declared.unique === true, declared.name);
+  }
+  for (const declared of explicitIndexes[logicalModelName] ?? []) {
+    add(declared.fields, declared.unique === true, declared.name);
+  }
+  for (const field of Object.values(fields)) {
+    if (field.indexed || field.unique || field.reference || field.sortable || field.physicalName === "createdAt") {
+      add([field.logicalName], field.unique);
+    }
+  }
+  return indexes;
+}
+function buildMetadata(tables) {
+  const models = {};
+  const tableByPhysicalName = new Map(
+    Object.values(tables).map((table) => [table.modelName, table])
+  );
+  for (const [logicalModelName, table] of Object.entries(tables)) {
+    const physicalModelName = table.modelName;
+    if (models[physicalModelName]) {
+      throw new Error(`AUTH_SCHEMA_DUPLICATE_MODEL:${physicalModelName}`);
+    }
+    const fields = {
+      id: {
+        logicalName: "id",
+        physicalName: "id",
+        kind: "string",
+        nullable: false,
+        required: true,
+        indexed: true,
+        selectable: true,
+        sortable: false,
+        unique: true,
+        updatable: false
+      }
+    };
+    for (const [logicalFieldName, rawField] of Object.entries(table.fields)) {
+      if (logicalFieldName === "id") continue;
+      const field = rawField;
+      const physicalName = physicalFieldName(logicalFieldName, field);
+      if (fields[physicalName]) {
+        throw new Error(`AUTH_SCHEMA_DUPLICATE_FIELD:${physicalModelName}.${physicalName}`);
+      }
+      let reference;
+      if (field.references) {
+        const referencedTable = tableByPhysicalName.get(field.references.model);
+        if (!referencedTable) {
+          throw new Error(
+            `AUTH_SCHEMA_REFERENCE_MODEL_UNKNOWN:${physicalModelName}.${physicalName}`
+          );
+        }
+        const referencedRawField = field.references.field === "id" ? void 0 : referencedTable.fields[field.references.field];
+        if (field.references.field !== "id" && !referencedRawField) {
+          throw new Error(
+            `AUTH_SCHEMA_REFERENCE_FIELD_UNKNOWN:${physicalModelName}.${physicalName}`
+          );
+        }
+        const onDelete = field.references.onDelete ?? "cascade";
+        if (onDelete === "set default" || onDelete === "no action") {
+          throw new Error(
+            `AUTH_SCHEMA_REFERENCE_DELETE_UNSUPPORTED:${physicalModelName}.${physicalName}:${onDelete}`
+          );
+        }
+        if (onDelete === "set null" && field.required === true) {
+          throw new Error(
+            `AUTH_SCHEMA_REFERENCE_SET_NULL_REQUIRED:${physicalModelName}.${physicalName}`
+          );
+        }
+        reference = {
+          model: referencedTable.modelName,
+          field: field.references.field === "id" ? "id" : physicalFieldName(field.references.field, referencedRawField),
+          onDelete
+        };
+      }
+      fields[physicalName] = {
+        logicalName: logicalFieldName,
+        physicalName,
+        kind: fieldKind(field),
+        nullable: field.required !== true,
+        required: field.required === true,
+        indexed: field.index === true,
+        selectable: true,
+        sortable: field.sortable === true,
+        unique: field.unique === true,
+        updatable: true,
+        ...reference ? { reference } : {}
+      };
+    }
+    models[physicalModelName] = {
+      logicalName: logicalModelName,
+      physicalName: physicalModelName,
+      fields,
+      indexes: buildIndexes(logicalModelName, fields, table.indexes ?? [])
+    };
+  }
+  for (const model of Object.values(models)) {
+    for (const field of Object.values(model.fields)) {
+      if (!field.reference) continue;
+      const referencedModel = models[field.reference.model];
+      const referencedField = referencedModel?.fields[field.reference.field];
+      if (!referencedModel || !referencedField) {
+        throw new Error(
+          `AUTH_SCHEMA_REFERENCE_TARGET_UNKNOWN:${model.physicalName}.${field.physicalName}`
+        );
+      }
+      if (!referencedModel.indexes.some(
+        (index) => index.fields.length === 1 && index.fields[0] === referencedField.physicalName
+      )) {
+        throw new Error(
+          `AUTH_SCHEMA_REFERENCE_TARGET_UNINDEXED:${model.physicalName}.${field.physicalName}`
+        );
+      }
+    }
+  }
+  return { fingerprint: fingerprintAuthSchemaModels(models), models };
+}
+function renderString(value) {
+  let escaped = "";
+  for (const character of value) {
+    switch (character) {
+      case "\\":
+        escaped += "\\\\";
+        break;
+      case "'":
+        escaped += "\\'";
+        break;
+      case "\b":
+        escaped += "\\b";
+        break;
+      case "\f":
+        escaped += "\\f";
+        break;
+      case "\n":
+        escaped += "\\n";
+        break;
+      case "\r":
+        escaped += "\\r";
+        break;
+      case "	":
+        escaped += "\\t";
+        break;
+      case "\u2028":
+        escaped += "\\u2028";
+        break;
+      case "\u2029":
+        escaped += "\\u2029";
+        break;
+      default: {
+        const codePoint = character.codePointAt(0);
+        escaped += codePoint <= 31 ? `\\u${codePoint.toString(16).padStart(4, "0")}` : character;
+      }
+    }
+  }
+  return `'${escaped}'`;
+}
+function renderPropertyName(value) {
+  return /^[A-Z_$][\w$]*$/iu.test(value) ? value : renderString(value);
+}
+function renderValue(value, depth = 0) {
+  if (typeof value === "string") return renderString(value);
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (value === null) return "null";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.every((item) => item === null || typeof item !== "object")) {
+      return `[${value.map((item) => renderValue(item, depth)).join(", ")}]`;
+    }
+    const indentation = "  ".repeat(depth);
+    const itemIndentation = "  ".repeat(depth + 1);
+    return `[
+${value.map((item) => `${itemIndentation}${renderValue(item, depth + 1)},`).join("\n")}
+${indentation}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    const indentation = "  ".repeat(depth);
+    const propertyIndentation = "  ".repeat(depth + 1);
+    return `{
+${entries.map(
+      ([key, item]) => `${propertyIndentation}${renderPropertyName(key)}: ${renderValue(item, depth + 1)},`
+    ).join("\n")}
+${indentation}}`;
+  }
+  throw new Error("AUTH_SCHEMA_UNSUPPORTED_METADATA_VALUE");
+}
+function renderMetadata(metadata) {
+  return [
+    "/** This file is generated by Better Convex Nuxt. Do not edit. */",
+    `const schemaMetadata = ${renderValue(metadata)} as const`,
+    "",
+    "export default schemaMetadata",
+    ""
+  ].join("\n");
+}
+function renderSchema(metadata) {
+  const models = Object.values(metadata.models);
+  const renderedModels = models.map((model) => {
+    const fields = Object.values(model.fields).map((field) => {
+      const validator = validatorForKind(field.kind);
+      return `    ${renderPropertyName(field.physicalName)}: ${field.nullable ? `v.union(v.null(), ${validator})` : validator},`;
+    }).join("\n");
+    const indexCalls = model.indexes.map(
+      (index) => `.index(${renderString(index.descriptor)}, ${renderValue(index.fields)})`
+    );
+    const indexes = indexCalls.length === 1 && `  })${indexCalls[0]},`.length <= 100 ? indexCalls[0] : indexCalls.map((call) => `
+    ${call}`).join("");
+    return `  ${renderPropertyName(model.physicalName)}: defineTable({
+${fields}
+  })${indexes},`;
+  });
+  return [
+    "/** This file is generated by Better Convex Nuxt. Do not edit. */",
+    "import { defineSchema, defineTable } from 'convex/server'",
+    "import { v } from 'convex/values'",
+    "",
+    "export const tables = {",
+    ...renderedModels,
+    "} as const",
+    "",
+    "const schema = defineSchema(tables)",
+    `Object.defineProperty(schema, '__betterConvexNuxtAuthSchemaFingerprint', {`,
+    `  value: ${renderString(metadata.fingerprint)},`,
+    "})",
+    "",
+    "export default schema",
+    ""
+  ].join("\n");
+}
+export function generateAuthSchemaArtifacts(tables) {
+  const metadata = buildMetadata(tables);
+  return {
+    metadata,
+    metadataCode: renderMetadata(metadata),
+    schemaCode: renderSchema(metadata)
+  };
+}
+export async function createAuthSchema({
+  file,
+  tables
+}) {
+  const artifacts = generateAuthSchemaArtifacts(tables);
+  const target = file ?? "./schema.ts";
+  return {
+    code: artifacts.schemaCode,
+    path: target,
+    overwrite: true
+  };
+}

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

@@ -0,0 +1,44 @@
+export type AuthFieldKind = 'string' | 'number' | 'boolean' | 'date' | 'json' | 'string[]' | 'number[]';
+export interface AuthReferenceMetadata {
+    model: string;
+    field: string;
+    onDelete: 'cascade' | 'restrict' | 'set null';
+}
+export interface AuthFieldMetadata {
+    logicalName: string;
+    physicalName: string;
+    kind: AuthFieldKind;
+    nullable: boolean;
+    required: boolean;
+    indexed: boolean;
+    selectable: boolean;
+    sortable: boolean;
+    unique: boolean;
+    updatable: boolean;
+    reference?: AuthReferenceMetadata;
+}
+export interface AuthIndexMetadata {
+    descriptor: string;
+    fields: readonly string[];
+    unique?: true;
+}
+export interface AuthModelMetadata {
+    logicalName: string;
+    physicalName: string;
+    fields: Readonly<Record<string, AuthFieldMetadata>>;
+    indexes: readonly AuthIndexMetadata[];
+}
+export interface AuthSchemaMetadata {
+    fingerprint: string;
+    models: Readonly<Record<string, AuthModelMetadata>>;
+}
+export declare const AUTH_SCHEMA_FINGERPRINT_PREFIX = "bcn-auth-schema-v2:";
+/** Compute the canonical fingerprint for every runtime-significant metadata field. */
+export declare function fingerprintAuthSchemaModels(models: AuthSchemaMetadata['models']): string;
+/**
+ * Fail at component definition time when generated schema and metadata are not
+ * the exact pair produced by one generator run.
+ */
+export declare function assertAuthSchemaMatchesMetadata(schema: unknown, metadata: AuthSchemaMetadata): void;
+export declare function getAuthModelMetadata(metadata: AuthSchemaMetadata, model: string): AuthModelMetadata;
+export declare function getAuthFieldMetadata(metadata: AuthSchemaMetadata, model: string, field: string): AuthFieldMetadata;

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

@@ -0,0 +1,91 @@
+export const AUTH_SCHEMA_FINGERPRINT_PREFIX = "bcn-auth-schema-v2:";
+const FNV64_OFFSET_BASIS = 14695981039346656037n;
+const FNV64_PRIME = 1099511628211n;
+const AUTH_SCHEMA_FINGERPRINT_PROPERTY = "__betterConvexNuxtAuthSchemaFingerprint";
+export function fingerprintAuthSchemaModels(models) {
+  let hash = FNV64_OFFSET_BASIS;
+  for (const codeUnit of JSON.stringify(models)) {
+    hash ^= BigInt(codeUnit.charCodeAt(0));
+    hash = BigInt.asUintN(64, hash * FNV64_PRIME);
+  }
+  return `${AUTH_SCHEMA_FINGERPRINT_PREFIX}${hash.toString(16).padStart(16, "0")}`;
+}
+function mismatch() {
+  throw new Error("AUTH_SCHEMA_METADATA_MISMATCH");
+}
+function sameStrings(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function expectedBaseValidator(kind) {
+  switch (kind) {
+    case "string":
+    case "json":
+      return { type: "string" };
+    case "number":
+    case "date":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "string[]":
+      return { type: "array", value: { type: "string" } };
+    case "number[]":
+      return { type: "array", value: { type: "number" } };
+  }
+}
+function validatorMatches(field, actual) {
+  const base = expectedBaseValidator(field.kind);
+  const expected = field.nullable ? { type: "union", value: [{ type: "null" }, base] } : base;
+  return JSON.stringify(actual) === JSON.stringify(expected);
+}
+export function assertAuthSchemaMatchesMetadata(schema, metadata) {
+  try {
+    if (schema === null || typeof schema !== "object") mismatch();
+    const schemaRecord = schema;
+    const exportSchema = schemaRecord.export;
+    if (typeof exportSchema !== "function" || typeof metadata.fingerprint !== "string" || !metadata.fingerprint.startsWith(AUTH_SCHEMA_FINGERPRINT_PREFIX) || metadata.fingerprint.length !== AUTH_SCHEMA_FINGERPRINT_PREFIX.length + 16 || fingerprintAuthSchemaModels(metadata.models) !== metadata.fingerprint || schemaRecord[AUTH_SCHEMA_FINGERPRINT_PROPERTY] !== metadata.fingerprint) {
+      mismatch();
+    }
+    const exported = JSON.parse(exportSchema.call(schema));
+    if (!exported || !Array.isArray(exported.tables)) mismatch();
+    const models = Object.values(metadata.models);
+    if (models.length !== exported.tables.length) mismatch();
+    const tablesByName = new Map(exported.tables.map((table) => [table.tableName, table]));
+    for (const model of models) {
+      if (metadata.models[model.physicalName] !== model) mismatch();
+      const table = tablesByName.get(model.physicalName);
+      if (!table || table.documentType?.type !== "object") mismatch();
+      if (table.searchIndexes.length > 0 || table.stagedDbIndexes.length > 0 || table.stagedSearchIndexes.length > 0 || table.vectorIndexes.length > 0 || table.stagedVectorIndexes.length > 0) {
+        mismatch();
+      }
+      const fields = Object.values(model.fields);
+      const exportedFields = table.documentType.value;
+      if (fields.length !== Object.keys(exportedFields).length) mismatch();
+      for (const field of fields) {
+        if (model.fields[field.physicalName] !== field) mismatch();
+        const exportedField = exportedFields[field.physicalName];
+        if (!exportedField || exportedField.optional !== false || !validatorMatches(field, exportedField.fieldType)) {
+          mismatch();
+        }
+      }
+      if (model.indexes.length !== table.indexes.length) mismatch();
+      for (const index of model.indexes) {
+        const exportedIndex = table.indexes.find(
+          (candidate) => candidate.indexDescriptor === index.descriptor
+        );
+        if (!exportedIndex || !sameStrings(index.fields, exportedIndex.fields)) mismatch();
+      }
+    }
+  } catch {
+    mismatch();
+  }
+}
+export function getAuthModelMetadata(metadata, model) {
+  const result = metadata.models[model];
+  if (!result) throw new Error(`AUTH_MODEL_UNKNOWN:${model}`);
+  return result;
+}
+export function getAuthFieldMetadata(metadata, model, field) {
+  const result = getAuthModelMetadata(metadata, model).fields[field];
+  if (!result) throw new Error(`AUTH_FIELD_UNKNOWN:${model}.${field}`);
+  return result;
+}

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

@@ -0,0 +1,32 @@
+import type { GenericQueryCtx, PaginationOptions, SchemaDefinition } from 'convex/server';
+import type { AuthSchemaMetadata } from './metadata.js';
+export type AuthWhereOperator = 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'in' | 'not_in' | 'ne' | 'contains' | 'starts_with' | 'ends_with';
+export interface AuthWhere {
+    field: string;
+    operator?: AuthWhereOperator;
+    value: string | number | boolean | readonly string[] | readonly number[] | null;
+    connector?: 'AND' | 'OR';
+    mode?: 'sensitive' | 'insensitive';
+}
+export interface AuthReadArgs {
+    model: string;
+    where?: readonly AuthWhere[];
+    select?: readonly string[];
+    sortBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    offset?: number;
+}
+export declare function matchesAuthWhere(doc: Record<string, unknown>, where?: readonly AuthWhere[]): boolean;
+export declare function validateAuthReadArgs(metadata: AuthSchemaMetadata, args: AuthReadArgs): void;
+export declare function toBetterAuthDocument(doc: Record<string, unknown> | null, select?: readonly string[]): Record<string, unknown> | null;
+export declare function paginateAuthRows(ctx: GenericQueryCtx<any>, schema: SchemaDefinition<any, any>, metadata: AuthSchemaMetadata, args: AuthReadArgs, paginationOpts: PaginationOptions): Promise<any>;
+export declare function collectAuthRows(ctx: GenericQueryCtx<any>, schema: SchemaDefinition<any, any>, metadata: AuthSchemaMetadata, args: AuthReadArgs, maximum?: number): Promise<Record<string, unknown>[]>;
+/**
+ * Count the complete result set in one component query with bounded page
+ * memory. It has no product-defined row ceiling and uses the same selector as
+ * fully paginated `findMany` and atomic bulk mutations.
+ */
+export declare function countAuthRows(ctx: GenericQueryCtx<any>, schema: SchemaDefinition<any, any>, metadata: AuthSchemaMetadata, args: AuthReadArgs): Promise<number>;
+export declare function findAuthRows(ctx: GenericQueryCtx<any>, schema: SchemaDefinition<any, any>, metadata: AuthSchemaMetadata, args: AuthReadArgs, maximum?: number): Promise<Record<string, unknown>[]>;