convex-helpers 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,19 @@
+# convex-helpers
+
+A collection of useful code to complement the official packages.
+
+## Row-level security
+
+See the [Stack post on row-level security](https://stack.convex.dev/row-level-security)
+
+Use the [RowLevelSecurity](./server/rowLevelSecurity.ts) helper to define
+`withQueryRLS` and `withMutationRLS` wrappers to add row-level checks for a
+server-side function. Any access to `db` inside functions wrapped with these
+will check your access rules on read/insert/modify per-document.
+
+## Relationship helpers
+
+See the [Stack post on relationship helpers](https://stack.convex.dev/functional-relationships-helpers)
+and the [relationship schema structures post](https://stack.convex.dev/relationship-structures-let-s-talk-about-schemas).
+
+Use the helpers in [relationships.ts](./server/relationships.ts) to traverse database relationships in queries more cleanly.

package/index.ts

@@ -0,0 +1,26 @@
+/**
+ * asyncMap returns the results of applying an async function over an list.
+ *
+ * @param list - Iterable object of items, e.g. an Array, Set, Object.keys
+ * @param asyncTransform
+ * @returns
+ */
+export async function asyncMap<FromType, ToType>(
+  list: Iterable<FromType>,
+  asyncTransform: (item: FromType) => Promise<ToType>
+): Promise<ToType[]> {
+  const promises: Promise<ToType>[] = [];
+  for (const item of list) {
+    promises.push(asyncTransform(item));
+  }
+  return Promise.all(promises);
+}
+
+/**
+ * Filters out null elements from an array.
+ * @param list List of elements that might be null.
+ * @returns List of elements with nulls removed.
+ */
+export function pruneNull<T>(list: (T | null)[]): T[] {
+  return list.filter((i) => i !== null) as T[];
+}

package/package.json

@@ -1,30 +1,15 @@
 {
   "name": "convex-helpers",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A collection of useful code to complement the official convex package.",
-  "exports": {
-    "./server/": {
-      "types": "./server/",
-      "import": "./esm/server/",
-      "require": "./cjs/server/"
-    }
-  },
-  "files": [
-    "esm",
-    "cjs",
-    "server"
-  ],
+  "type": "module",
   "scripts": {
-    "build": "npm run clean && npm run build:esm 2>/dev/null && npm run build:cjs 2>/dev/null",
-    "clean": "rm -rf cjs esm",
-    "build:esm": "esbuild **/*.ts --outdir=esm --outbase=. --loader:.ts=ts --platform=node --bundle=false",
-    "build:cjs": "esbuild **/*.ts --outdir=cjs --outbase=. --loader:.ts=ts --platform=node --bundle=false --format=cjs && echo '{\"type\": \"commonjs\"}' > cjs/package.json",
-    "watch": "chokidar '**/*.tsx' '**/*.ts' 'package.json' -c 'npm run build:esm'",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/get-convex/convex-helpers.git"
+    "url": "git+https://github.com/get-convex/convex-helpers.git",
+    "directory": "packages/convex-helpers"
   },
   "keywords": [
     "convex",
@@ -36,13 +21,11 @@
   "bugs": {
     "url": "https://github.com/get-convex/convex-helpers/issues"
   },
-  "homepage": "https://github.com/get-convex/convex-helpers#readme",
-  "dependencies": {},
+  "homepage": "https://github.com/get-convex/convex-helpers/tree/main/packages/convex-helpers/README.md",
   "peerDependencies": {
-    "convex": "^1.6.2"
+    "convex": "^1.6.3"
   },
   "devDependencies": {
-    "chokidar-cli": "^3.0.0",
     "typescript": "^5.2.2"
   }
 }

package/server/middlewareUtils.ts

@@ -0,0 +1,102 @@
+import { ObjectType, PropertyValidators } from "convex/values";
+import {
+  ArgsArray,
+  UnvalidatedFunction,
+  ValidatedFunction,
+} from "convex/server";
+
+export type MergeArgs<
+  Args extends ArgsArray,
+  Other extends { [k: string]: any }
+> = Args extends [] ? [Other] : [Args[0] & Other];
+
+export type MergeArgsForRegistered<
+  Args extends ArgsArray,
+  Other extends { [k: string]: any }
+> = MergeArgs<Args, Other>[0];
+
+export function splitArgs<
+  ConsumedArgsValidator extends PropertyValidators,
+  Args extends Record<string, any>
+>(
+  consumedArgsValidator: ConsumedArgsValidator,
+  args: Args & ObjectType<ConsumedArgsValidator>
+): { rest: Args; consumed: ObjectType<ConsumedArgsValidator> } {
+  const rest: Record<string, any> = {};
+  const consumed: Record<string, any> = {};
+  for (const arg in args) {
+    if (arg in consumedArgsValidator) {
+      consumed[arg] = args[arg];
+    } else {
+      rest[arg] = args[arg];
+    }
+  }
+
+  return {
+    rest,
+    consumed,
+  } as any;
+}
+
+export const generateMiddleware = <
+  RequiredCtx extends Record<string, any>,
+  TransformedCtx extends Record<string, any>,
+  ConsumedArgsValidator extends PropertyValidators
+>(
+  consumedArgsValidator: ConsumedArgsValidator,
+  transformContext: (
+    ctx: RequiredCtx,
+    args: ObjectType<ConsumedArgsValidator>
+  ) => Promise<TransformedCtx>
+) => {
+  // Have two overloads -- one for validated functions and one for unvalidated functions
+  function withFoo<
+    ExistingArgsValidator extends PropertyValidators,
+    Output,
+    Ctx
+  >(
+    fn: ValidatedFunction<
+      Ctx & TransformedCtx,
+      ExistingArgsValidator,
+      Promise<Output>
+    >
+  ): ValidatedFunction<
+    Ctx & RequiredCtx,
+    ConsumedArgsValidator & ExistingArgsValidator,
+    Promise<Output>
+  >;
+
+  function withFoo<ExistingArgs extends ArgsArray, Output, Ctx>(
+    fn: UnvalidatedFunction<Ctx & TransformedCtx, ExistingArgs, Promise<Output>>
+  ): UnvalidatedFunction<
+    Ctx & RequiredCtx,
+    MergeArgs<ExistingArgs, ObjectType<ConsumedArgsValidator>>,
+    Promise<Output>
+  >;
+  function withFoo(fn: any): any {
+    if (fn.args) {
+      const handler = fn.handler;
+      return {
+        args: {
+          ...fn.args,
+          ...consumedArgsValidator,
+        },
+        handler: async (ctx: any, allArgs: any) => {
+          const { rest, consumed } = splitArgs(consumedArgsValidator, allArgs);
+          const transformedCtx = await transformContext(ctx, consumed);
+          return await handler(transformedCtx, rest);
+        },
+      };
+    }
+    const handler = fn.handler ?? fn;
+    return {
+      handler: async (ctx: any, allArgs: any) => {
+        const { rest, consumed } = splitArgs(consumedArgsValidator, allArgs);
+        const transformedCtx = await transformContext(ctx, consumed);
+        return await handler(transformedCtx, rest);
+      },
+    };
+  }
+
+  return withFoo;
+};

package/server/relationships.ts

@@ -6,26 +6,10 @@ import {
   GenericDataModel,
   GenericDatabaseReader,
   DocumentByName,
+  SystemTableNames,
 } from "convex/server";
 import { ConvexError, GenericId } from "convex/values";
-
-/**
- * asyncMap returns the results of applying an async function over an list.
- *
- * @param list - Iterable object of items, e.g. an Array, Set, Object.keys
- * @param asyncTransform
- * @returns
- */
-export async function asyncMap<FromType, ToType>(
-  list: Iterable<FromType>,
-  asyncTransform: (item: FromType) => Promise<ToType>
-): Promise<ToType[]> {
-  const promises: Promise<ToType>[] = [];
-  for (const item of list) {
-    promises.push(asyncTransform(item));
-  }
-  return Promise.all(promises);
-}
+import { asyncMap, pruneNull } from "..";
 
 /**
  * getAll returns a list of Documents corresponding to the `Id`s passed in.
@@ -176,7 +160,7 @@ export async function getManyFrom<
 type IdFilePaths<
   DataModel extends GenericDataModel,
   InTableName extends TablesWithLookups<DataModel>,
-  TableName extends TableNamesInDataModel<DataModel>
+  TableName extends TableNamesInDataModel<DataModel> | SystemTableNames
 > = {
   [FieldName in DataModel[InTableName]["fieldPaths"]]: FieldTypeFromFieldPath<
     DocumentByName<DataModel, InTableName>,
@@ -198,9 +182,13 @@ type LookupAndIdFilePaths<
   [FieldPath in IdFilePaths<
     DataModel,
     TableName,
-    TableNamesInDataModel<DataModel>
+    TableNamesInDataModel<DataModel> | SystemTableNames
   >]: LookupFieldPaths<DataModel, TableName> extends FieldPath ? never : true;
-}[IdFilePaths<DataModel, TableName, TableNamesInDataModel<DataModel>>];
+}[IdFilePaths<
+  DataModel,
+  TableName,
+  TableNamesInDataModel<DataModel> | SystemTableNames
+>];
 
 // The table names that  match LookupAndIdFields.
 // These are the possible "join" or "edge" or "relationship" tables.
@@ -233,7 +221,7 @@ export async function getManyVia<
   ToField extends IdFilePaths<
     DataModel,
     JoinTableName,
-    TableNamesInDataModel<DataModel>
+    TableNamesInDataModel<DataModel> | SystemTableNames
   >,
   FromField extends Exclude<
     LookupFieldPaths<DataModel, JoinTableName>,
@@ -256,17 +244,16 @@ export async function getManyVia<
   >
 ): Promise<DocumentByName<DataModel, TargetTableName>[]> {
   return pruneNull(
-    await asyncMap(await getManyFrom(db, table, fromField, value), (link) =>
-      db.get((link as any)[toField])
+    await asyncMap(
+      await getManyFrom(db, table, fromField, value),
+      async (link: DocumentByName<DataModel, JoinTableName>) => {
+        const id = link[toField] as GenericId<TargetTableName>;
+        try {
+          return await db.get(id);
+        } catch {
+          return await db.system.get(id as GenericId<SystemTableNames>);
+        }
+      }
     )
   );
 }
-
-/**
- * Filters out null elements from an array.
- * @param list List of elements that might be null.
- * @returns List of elements with nulls removed.
- */
-export function pruneNull<T>(list: (T | null)[]): T[] {
-  return list.filter((i) => i !== null) as T[];
-}

package/tsconfig.json

@@ -0,0 +1,112 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ESNext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "force",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "ESNext",                                /* Specify what module code is generated. */
+    "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "Node",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    // "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+  "include": [
+    "."
+  ]
+}

package/cjs/package.json

@@ -1 +0,0 @@
-{"type": "commonjs"}

package/cjs/server/relationships.js

@@ -1,81 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var relationships_exports = {};
-__export(relationships_exports, {
-  asyncMap: () => asyncMap,
-  getAll: () => getAll,
-  getAllWithNulls: () => getAllWithNulls,
-  getManyFrom: () => getManyFrom,
-  getManyVia: () => getManyVia,
-  getOneFrom: () => getOneFrom,
-  getOneOrNullFrom: () => getOneOrNullFrom,
-  pruneNull: () => pruneNull
-});
-module.exports = __toCommonJS(relationships_exports);
-var import_values = require("convex/values");
-async function asyncMap(list, asyncTransform) {
-  const promises = [];
-  for (const item of list) {
-    promises.push(asyncTransform(item));
-  }
-  return Promise.all(promises);
-}
-async function getAll(db, ids) {
-  return pruneNull(await asyncMap(ids, db.get));
-}
-async function getAllWithNulls(db, ids) {
-  return asyncMap(ids, db.get);
-}
-async function getOneFrom(db, table, field, value) {
-  const ret = await db.query(table).withIndex("by_" + field, (q) => q.eq(field, value)).unique();
-  if (ret === null) {
-    throw new import_values.ConvexError(
-      `Can't find a document in ${table} with field ${field} equal to ${value}`
-    );
-  }
-  return ret;
-}
-async function getOneOrNullFrom(db, table, field, value) {
-  return db.query(table).withIndex("by_" + field, (q) => q.eq(field, value)).unique();
-}
-async function getManyFrom(db, table, field, value) {
-  return db.query(table).withIndex("by_" + field, (q) => q.eq(field, value)).collect();
-}
-async function getManyVia(db, table, toField, fromField, value) {
-  return pruneNull(
-    await asyncMap(
-      await getManyFrom(db, table, fromField, value),
-      (link) => db.get(link[toField])
-    )
-  );
-}
-function pruneNull(list) {
-  return list.filter((i) => i !== null);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  asyncMap,
-  getAll,
-  getAllWithNulls,
-  getManyFrom,
-  getManyVia,
-  getOneFrom,
-  getOneOrNullFrom,
-  pruneNull
-});

package/cjs/server/rowLevelSecurity.js

@@ -1,273 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var rowLevelSecurity_exports = {};
-__export(rowLevelSecurity_exports, {
-  RowLevelSecurity: () => RowLevelSecurity
-});
-module.exports = __toCommonJS(rowLevelSecurity_exports);
-const RowLevelSecurity = (rules) => {
-  const withMutationRLS = (f) => {
-    return (ctx, ...args) => {
-      const wrappedDb = new WrapWriter(ctx, ctx.db, rules);
-      return f({ ...ctx, db: wrappedDb }, ...args);
-    };
-  };
-  const withQueryRLS = (f) => {
-    return (ctx, ...args) => {
-      const wrappedDb = new WrapReader(ctx, ctx.db, rules);
-      return f({ ...ctx, db: wrappedDb }, ...args);
-    };
-  };
-  return {
-    withMutationRLS,
-    withQueryRLS
-  };
-};
-async function asyncFilter(arr, predicate) {
-  const results = await Promise.all(arr.map(predicate));
-  return arr.filter((_v, index) => results[index]);
-}
-class WrapQuery {
-  q;
-  p;
-  iterator;
-  constructor(q, p) {
-    this.q = q;
-    this.p = p;
-  }
-  filter(predicate) {
-    return new WrapQuery(this.q.filter(predicate), this.p);
-  }
-  order(order) {
-    return new WrapQuery(this.q.order(order), this.p);
-  }
-  async paginate(paginationOpts) {
-    const result = await this.q.paginate(paginationOpts);
-    result.page = await asyncFilter(result.page, this.p);
-    return result;
-  }
-  async collect() {
-    const results = await this.q.collect();
-    return await asyncFilter(results, this.p);
-  }
-  async take(n) {
-    const results = [];
-    for await (const result of this) {
-      results.push(result);
-      if (results.length >= n) {
-        break;
-      }
-    }
-    return results;
-  }
-  async first() {
-    for await (const result of this) {
-      return result;
-    }
-    return null;
-  }
-  async unique() {
-    let uniqueResult = null;
-    for await (const result of this) {
-      if (uniqueResult === null) {
-        uniqueResult = result;
-      } else {
-        throw new Error("not unique");
-      }
-    }
-    return uniqueResult;
-  }
-  [Symbol.asyncIterator]() {
-    this.iterator = this.q[Symbol.asyncIterator]();
-    return this;
-  }
-  async next() {
-    for (; ; ) {
-      const { value, done } = await this.iterator.next();
-      if (value && await this.p(value)) {
-        return { value, done };
-      }
-      if (done) {
-        return { value: null, done: true };
-      }
-    }
-  }
-  return() {
-    return this.iterator.return();
-  }
-}
-class WrapQueryInitializer {
-  q;
-  p;
-  constructor(q, p) {
-    this.q = q;
-    this.p = p;
-  }
-  fullTableScan() {
-    return new WrapQuery(this.q.fullTableScan(), this.p);
-  }
-  withIndex(indexName, indexRange) {
-    return new WrapQuery(this.q.withIndex(indexName, indexRange), this.p);
-  }
-  withSearchIndex(indexName, searchFilter) {
-    return new WrapQuery(
-      this.q.withSearchIndex(indexName, searchFilter),
-      this.p
-    );
-  }
-  filter(predicate) {
-    return this.fullTableScan().filter(predicate);
-  }
-  order(order) {
-    return this.fullTableScan().order(order);
-  }
-  async paginate(paginationOpts) {
-    return this.fullTableScan().paginate(paginationOpts);
-  }
-  collect() {
-    return this.fullTableScan().collect();
-  }
-  take(n) {
-    return this.fullTableScan().take(n);
-  }
-  first() {
-    return this.fullTableScan().first();
-  }
-  unique() {
-    return this.fullTableScan().unique();
-  }
-  [Symbol.asyncIterator]() {
-    return this.fullTableScan()[Symbol.asyncIterator]();
-  }
-}
-class WrapReader {
-  ctx;
-  db;
-  rules;
-  constructor(ctx, db, rules) {
-    this.ctx = ctx;
-    this.db = db;
-    this.rules = rules;
-  }
-  normalizeId(tableName, id) {
-    return this.db.normalizeId(tableName, id);
-  }
-  tableName(id) {
-    for (const tableName of Object.keys(this.rules)) {
-      if (this.db.normalizeId(tableName, id)) {
-        return tableName;
-      }
-    }
-    return null;
-  }
-  async predicate(tableName, doc) {
-    if (!this.rules[tableName]?.read) {
-      return true;
-    }
-    return await this.rules[tableName].read(this.ctx, doc);
-  }
-  async get(id) {
-    const doc = await this.db.get(id);
-    if (doc) {
-      const tableName = this.tableName(id);
-      if (tableName && !await this.predicate(tableName, doc)) {
-        return null;
-      }
-      return doc;
-    }
-    return null;
-  }
-  query(tableName) {
-    return new WrapQueryInitializer(
-      this.db.query(tableName),
-      async (d) => await this.predicate(tableName, d)
-    );
-  }
-}
-class WrapWriter {
-  ctx;
-  db;
-  reader;
-  rules;
-  async modifyPredicate(tableName, doc) {
-    if (!this.rules[tableName]?.modify) {
-      return true;
-    }
-    return await this.rules[tableName].modify(this.ctx, doc);
-  }
-  constructor(ctx, db, rules) {
-    this.ctx = ctx;
-    this.db = db;
-    this.reader = new WrapReader(ctx, db, rules);
-    this.rules = rules;
-  }
-  normalizeId(tableName, id) {
-    return this.db.normalizeId(tableName, id);
-  }
-  async insert(table, value) {
-    const rules = this.rules[table];
-    if (rules?.insert && !await rules.insert(this.ctx, value)) {
-      throw new Error("insert access not allowed");
-    }
-    return await this.db.insert(table, value);
-  }
-  tableName(id) {
-    for (const tableName of Object.keys(this.rules)) {
-      if (this.db.normalizeId(tableName, id)) {
-        return tableName;
-      }
-    }
-    return null;
-  }
-  async checkAuth(id) {
-    const doc = await this.get(id);
-    if (doc === null) {
-      throw new Error("no read access or doc does not exist");
-    }
-    const tableName = this.tableName(id);
-    if (tableName === null) {
-      return;
-    }
-    if (!await this.modifyPredicate(tableName, doc)) {
-      throw new Error("write access not allowed");
-    }
-  }
-  async patch(id, value) {
-    await this.checkAuth(id);
-    return await this.db.patch(id, value);
-  }
-  async replace(id, value) {
-    await this.checkAuth(id);
-    return await this.db.replace(id, value);
-  }
-  async delete(id) {
-    await this.checkAuth(id);
-    return await this.db.delete(id);
-  }
-  get(id) {
-    return this.reader.get(id);
-  }
-  query(tableName) {
-    return this.reader.query(tableName);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RowLevelSecurity
-});

package/esm/server/relationships.js

@@ -1,41 +0,0 @@
-"use strict";
-import { ConvexError } from "convex/values";
-export async function asyncMap(list, asyncTransform) {
-  const promises = [];
-  for (const item of list) {
-    promises.push(asyncTransform(item));
-  }
-  return Promise.all(promises);
-}
-export async function getAll(db, ids) {
-  return pruneNull(await asyncMap(ids, db.get));
-}
-export async function getAllWithNulls(db, ids) {
-  return asyncMap(ids, db.get);
-}
-export async function getOneFrom(db, table, field, value) {
-  const ret = await db.query(table).withIndex("by_" + field, (q) => q.eq(field, value)).unique();
-  if (ret === null) {
-    throw new ConvexError(
-      `Can't find a document in ${table} with field ${field} equal to ${value}`
-    );
-  }
-  return ret;
-}
-export async function getOneOrNullFrom(db, table, field, value) {
-  return db.query(table).withIndex("by_" + field, (q) => q.eq(field, value)).unique();
-}
-export async function getManyFrom(db, table, field, value) {
-  return db.query(table).withIndex("by_" + field, (q) => q.eq(field, value)).collect();
-}
-export async function getManyVia(db, table, toField, fromField, value) {
-  return pruneNull(
-    await asyncMap(
-      await getManyFrom(db, table, fromField, value),
-      (link) => db.get(link[toField])
-    )
-  );
-}
-export function pruneNull(list) {
-  return list.filter((i) => i !== null);
-}

package/esm/server/rowLevelSecurity.js

@@ -1,251 +0,0 @@
-"use strict";
-export const RowLevelSecurity = (rules) => {
-  const withMutationRLS = (f) => {
-    return (ctx, ...args) => {
-      const wrappedDb = new WrapWriter(ctx, ctx.db, rules);
-      return f({ ...ctx, db: wrappedDb }, ...args);
-    };
-  };
-  const withQueryRLS = (f) => {
-    return (ctx, ...args) => {
-      const wrappedDb = new WrapReader(ctx, ctx.db, rules);
-      return f({ ...ctx, db: wrappedDb }, ...args);
-    };
-  };
-  return {
-    withMutationRLS,
-    withQueryRLS
-  };
-};
-async function asyncFilter(arr, predicate) {
-  const results = await Promise.all(arr.map(predicate));
-  return arr.filter((_v, index) => results[index]);
-}
-class WrapQuery {
-  q;
-  p;
-  iterator;
-  constructor(q, p) {
-    this.q = q;
-    this.p = p;
-  }
-  filter(predicate) {
-    return new WrapQuery(this.q.filter(predicate), this.p);
-  }
-  order(order) {
-    return new WrapQuery(this.q.order(order), this.p);
-  }
-  async paginate(paginationOpts) {
-    const result = await this.q.paginate(paginationOpts);
-    result.page = await asyncFilter(result.page, this.p);
-    return result;
-  }
-  async collect() {
-    const results = await this.q.collect();
-    return await asyncFilter(results, this.p);
-  }
-  async take(n) {
-    const results = [];
-    for await (const result of this) {
-      results.push(result);
-      if (results.length >= n) {
-        break;
-      }
-    }
-    return results;
-  }
-  async first() {
-    for await (const result of this) {
-      return result;
-    }
-    return null;
-  }
-  async unique() {
-    let uniqueResult = null;
-    for await (const result of this) {
-      if (uniqueResult === null) {
-        uniqueResult = result;
-      } else {
-        throw new Error("not unique");
-      }
-    }
-    return uniqueResult;
-  }
-  [Symbol.asyncIterator]() {
-    this.iterator = this.q[Symbol.asyncIterator]();
-    return this;
-  }
-  async next() {
-    for (; ; ) {
-      const { value, done } = await this.iterator.next();
-      if (value && await this.p(value)) {
-        return { value, done };
-      }
-      if (done) {
-        return { value: null, done: true };
-      }
-    }
-  }
-  return() {
-    return this.iterator.return();
-  }
-}
-class WrapQueryInitializer {
-  q;
-  p;
-  constructor(q, p) {
-    this.q = q;
-    this.p = p;
-  }
-  fullTableScan() {
-    return new WrapQuery(this.q.fullTableScan(), this.p);
-  }
-  withIndex(indexName, indexRange) {
-    return new WrapQuery(this.q.withIndex(indexName, indexRange), this.p);
-  }
-  withSearchIndex(indexName, searchFilter) {
-    return new WrapQuery(
-      this.q.withSearchIndex(indexName, searchFilter),
-      this.p
-    );
-  }
-  filter(predicate) {
-    return this.fullTableScan().filter(predicate);
-  }
-  order(order) {
-    return this.fullTableScan().order(order);
-  }
-  async paginate(paginationOpts) {
-    return this.fullTableScan().paginate(paginationOpts);
-  }
-  collect() {
-    return this.fullTableScan().collect();
-  }
-  take(n) {
-    return this.fullTableScan().take(n);
-  }
-  first() {
-    return this.fullTableScan().first();
-  }
-  unique() {
-    return this.fullTableScan().unique();
-  }
-  [Symbol.asyncIterator]() {
-    return this.fullTableScan()[Symbol.asyncIterator]();
-  }
-}
-class WrapReader {
-  ctx;
-  db;
-  system;
-  rules;
-  constructor(ctx, db, rules) {
-    this.ctx = ctx;
-    this.db = db;
-    this.system = db.system;
-    this.rules = rules;
-  }
-  normalizeId(tableName, id) {
-    return this.db.normalizeId(tableName, id);
-  }
-  tableName(id) {
-    for (const tableName of Object.keys(this.rules)) {
-      if (this.db.normalizeId(tableName, id)) {
-        return tableName;
-      }
-    }
-    return null;
-  }
-  async predicate(tableName, doc) {
-    if (!this.rules[tableName]?.read) {
-      return true;
-    }
-    return await this.rules[tableName].read(this.ctx, doc);
-  }
-  async get(id) {
-    const doc = await this.db.get(id);
-    if (doc) {
-      const tableName = this.tableName(id);
-      if (tableName && !await this.predicate(tableName, doc)) {
-        return null;
-      }
-      return doc;
-    }
-    return null;
-  }
-  query(tableName) {
-    return new WrapQueryInitializer(
-      this.db.query(tableName),
-      async (d) => await this.predicate(tableName, d)
-    );
-  }
-}
-class WrapWriter {
-  ctx;
-  db;
-  system;
-  reader;
-  rules;
-  async modifyPredicate(tableName, doc) {
-    if (!this.rules[tableName]?.modify) {
-      return true;
-    }
-    return await this.rules[tableName].modify(this.ctx, doc);
-  }
-  constructor(ctx, db, rules) {
-    this.ctx = ctx;
-    this.db = db;
-    this.system = db.system;
-    this.reader = new WrapReader(ctx, db, rules);
-    this.rules = rules;
-  }
-  normalizeId(tableName, id) {
-    return this.db.normalizeId(tableName, id);
-  }
-  async insert(table, value) {
-    const rules = this.rules[table];
-    if (rules?.insert && !await rules.insert(this.ctx, value)) {
-      throw new Error("insert access not allowed");
-    }
-    return await this.db.insert(table, value);
-  }
-  tableName(id) {
-    for (const tableName of Object.keys(this.rules)) {
-      if (this.db.normalizeId(tableName, id)) {
-        return tableName;
-      }
-    }
-    return null;
-  }
-  async checkAuth(id) {
-    const doc = await this.get(id);
-    if (doc === null) {
-      throw new Error("no read access or doc does not exist");
-    }
-    const tableName = this.tableName(id);
-    if (tableName === null) {
-      return;
-    }
-    if (!await this.modifyPredicate(tableName, doc)) {
-      throw new Error("write access not allowed");
-    }
-  }
-  async patch(id, value) {
-    await this.checkAuth(id);
-    return await this.db.patch(id, value);
-  }
-  async replace(id, value) {
-    await this.checkAuth(id);
-    return await this.db.replace(id, value);
-  }
-  async delete(id) {
-    await this.checkAuth(id);
-    return await this.db.delete(id);
-  }
-  get(id) {
-    return this.reader.get(id);
-  }
-  query(tableName) {
-    return this.reader.query(tableName);
-  }
-}