convex-verify 1.0.5 → 1.2.2

package/dist/index.mjs

@@ -1,101 +1,5 @@
-// src/core/plugin.ts
-function isValidatePlugin(obj) {
-  return typeof obj === "object" && obj !== null && "_type" in obj && typeof obj._type === "string" && "verify" in obj && typeof obj.verify === "object";
-}
-async function runValidatePlugins(plugins, context, data) {
-  let result = data;
-  for (const plugin of plugins) {
-    const verifyFn = context.operation === "insert" ? plugin.verify.insert : plugin.verify.patch;
-    if (verifyFn) {
-      result = await verifyFn(context, result);
-    }
-  }
-  return result;
-}
-function createValidatePlugin(type, config, verify) {
-  return {
-    _type: type,
-    config,
-    verify
-  };
-}
-
-// src/core/verifyConfig.ts
-var verifyConfig = (_schema, configs) => {
-  const validatePlugins = [
-    // Built-in validation configs (if provided as named keys)
-    ...configs.uniqueRow ? [configs.uniqueRow] : [],
-    ...configs.uniqueColumn ? [configs.uniqueColumn] : [],
-    // Additional plugins from the plugins array
-    ...configs.plugins ?? []
-  ];
-  const insert = async (ctx, tableName, data, options) => {
-    let verifiedData = data;
-    if (configs.defaultValues) {
-      verifiedData = await configs.defaultValues.verify(
-        tableName,
-        verifiedData
-      );
-    }
-    if (validatePlugins.length > 0) {
-      verifiedData = await runValidatePlugins(
-        validatePlugins,
-        {
-          ctx,
-          tableName,
-          operation: "insert",
-          onFail: options?.onFail,
-          schema: _schema
-        },
-        verifiedData
-      );
-    }
-    return await ctx.db.insert(tableName, verifiedData);
-  };
-  const patch = async (ctx, tableName, id, data, options) => {
-    let verifiedData = data;
-    if (validatePlugins.length > 0) {
-      verifiedData = await runValidatePlugins(
-        validatePlugins,
-        {
-          ctx,
-          tableName,
-          operation: "patch",
-          patchId: id,
-          onFail: options?.onFail,
-          schema: _schema
-        },
-        verifiedData
-      );
-    }
-    await ctx.db.patch(id, verifiedData);
-  };
-  const dangerouslyPatch = async (ctx, tableName, id, data, options) => {
-    let verifiedData = data;
-    if (validatePlugins.length > 0) {
-      verifiedData = await runValidatePlugins(
-        validatePlugins,
-        {
-          ctx,
-          tableName,
-          operation: "patch",
-          patchId: id,
-          onFail: options?.onFail,
-          schema: _schema
-        },
-        verifiedData
-      );
-    }
-    await ctx.db.patch(id, verifiedData);
-  };
-  return {
-    insert,
-    patch,
-    dangerouslyPatch,
-    // Expose configs for debugging/advanced usage
-    configs
-  };
-};
+// src/core/builtins.ts
+import { ConvexError } from "convex/values";
 
 // src/core/types.ts
 function normalizeIndexConfigEntry(entry, defaultIdentifiers = ["_id"]) {
@@ -113,33 +17,6 @@ function normalizeIndexConfigEntry(entry, defaultIdentifiers = ["_id"]) {
   };
 }
 
-// src/transforms/defaultValuesConfig.ts
-var defaultValuesConfig = (_schema, config) => {
-  const verify = async (tableName, data) => {
-    const resolvedConfig = typeof config === "function" ? await config() : config;
-    return {
-      ...resolvedConfig[tableName],
-      ...data
-    };
-  };
-  return {
-    _type: "defaultValues",
-    verify,
-    config
-  };
-};
-
-// src/configs/protectedColumnsConfig.ts
-var protectedColumnsConfig = (_schema, config) => {
-  return {
-    _type: "protectedColumns",
-    config
-  };
-};
-
-// src/plugins/uniqueRowConfig.ts
-import { ConvexError } from "convex/values";
-
 // src/utils/helpers.ts
 var getTableIndexes = (schema, tableName) => {
   return schema.tables[tableName][" indexes"]();
@@ -152,7 +29,7 @@ var constructColumnData = (fields, data, {
   const columnData = fields.map((_, index) => {
     const column = fields?.[index];
     const value = data?.[column];
-    if (!column || !allowNullishValue && !value) {
+    if (!column || !allowNullishValue && (value === void 0 || value === null)) {
       return;
     }
     return {
@@ -196,37 +73,108 @@ var constructIndexData = (schema, tableName, indexConfig) => {
   });
 };
 
-// src/plugins/uniqueRowConfig.ts
-var uniqueRowConfig = (schema, config) => {
+// src/core/builtins.ts
+var stripProtectedPatchColumns = (protectedColumns, tableName, data) => {
+  const protectedKeys = protectedColumns[tableName] ?? [];
+  if (protectedKeys.length === 0) {
+    return {
+      filteredData: data,
+      removedColumns: []
+    };
+  }
+  const protectedKeyStrings = protectedKeys.map(String);
+  const protectedKeySet = new Set(protectedKeyStrings);
+  const removedColumns = protectedKeyStrings.filter((key) => key in data);
+  if (removedColumns.length === 0) {
+    return {
+      filteredData: data,
+      removedColumns
+    };
+  }
+  const filteredData = Object.fromEntries(
+    Object.entries(data).filter(([key]) => !protectedKeySet.has(key))
+  );
+  return {
+    filteredData,
+    removedColumns
+  };
+};
+var buildDefaultValuesVerifier = (config) => {
+  const verify = (async (...args) => {
+    const input = args.length === 2 ? {
+      tableName: args[0],
+      operation: "insert",
+      data: args[1]
+    } : args[0];
+    if (input.operation === "patch") {
+      return input.data;
+    }
+    const resolvedConfig = typeof config === "function" ? await config() : config;
+    return {
+      ...resolvedConfig[input.tableName] ?? {},
+      ...input.data
+    };
+  });
+  return {
+    _type: "defaultValues",
+    config,
+    verify
+  };
+};
+var buildProtectedColumnsVerifier = (config) => {
+  const verify = (async (...args) => {
+    const input = args.length === 2 ? {
+      tableName: args[0],
+      operation: "patch",
+      data: args[1]
+    } : args[0];
+    if (input.operation === "insert") {
+      return input.data;
+    }
+    return stripProtectedPatchColumns(config, input.tableName, input.data).filteredData;
+  });
+  return {
+    _type: "protectedColumns",
+    config,
+    verify
+  };
+};
+var buildUniqueRowVerifier = (schema, config) => {
   const uniqueRowError = (message) => {
     throw new ConvexError({
       message,
       code: "UNIQUE_ROW_VERIFICATION_ERROR"
     });
   };
-  const verifyUniqueness = async (context, data, tableName) => {
-    const { ctx, operation, patchId, onFail } = context;
+  const verify = (async (...args) => {
+    const input = args.length === 3 ? {
+      ctx: args[0],
+      tableName: args[1],
+      operation: "insert",
+      data: args[2]
+    } : args.length === 4 ? {
+      ctx: args[0],
+      tableName: args[1],
+      operation: "patch",
+      patchId: args[2],
+      data: args[3]
+    } : args[0];
+    const { ctx, tableName, operation, patchId, onFail, data } = input;
     const indexesData = constructIndexData(schema, tableName, config);
-    if (!indexesData && !!config[tableName]) {
-      uniqueRowError(`Index data was not found where there should have been.`);
-    }
     if (!indexesData) {
       return data;
     }
     for (const indexInfo of indexesData) {
-      const { name, fields, identifiers, ...rest } = indexInfo;
-      const _options = rest;
-      if (!fields[0] && !fields[1]) {
+      const { name, fields, identifiers } = indexInfo;
+      if (fields.length < 2) {
         uniqueRowError(
-          `Error in 'verifyRowUniqueness()'. There must be two columns to test against. If you are attempting to enforce a unique column, use the 'uniqueColumns' config option.`
+          `Error in 'verifyRowUniqueness()'. There must be two columns to test against. If you are attempting to enforce a unique column, use the 'uniqueColumn' config option.`
         );
       }
       const columnData = constructColumnData(fields, data, {});
       const getExisting = async (cd) => {
         let existingByIndex = [];
-        if (!cd) {
-          existingByIndex = [];
-        } else {
+        if (cd) {
           existingByIndex = await ctx.db.query(tableName).withIndex(
             name,
             (q) => cd.reduce((query, { column, value }) => query.eq(column, value), q)
@@ -235,10 +183,10 @@ var uniqueRowConfig = (schema, config) => {
         if (existingByIndex.length > 1) {
           console.warn(
             `There was more than one existing result found for index ${name}. Check the following IDs:`,
-            existingByIndex.map((r) => r._id)
+            existingByIndex.map((row) => row._id)
           );
           console.warn(
-            `It is recommended that you triage the rows listed above since they have data that go against a rule of row uniqueness.`
+            "It is recommended that you triage the rows listed above since they have data that go against a rule of row uniqueness."
           );
         }
         return existingByIndex.length > 0 ? existingByIndex[0] : null;
@@ -254,91 +202,89 @@ var uniqueRowConfig = (schema, config) => {
           }
         });
         uniqueRowError(
-          `Unable to [${operation}] document. In table [${tableName}], there is an existing row that has the same data combination in the columns: [${fields.join(`, `)}].`
+          `Unable to [${operation}] document. In table [${tableName}], there is an existing row that has the same data combination in the columns: [${fields.join(", ")}].`
         );
       }
-      if (operation === "patch") {
-        if (!patchId) {
-          uniqueRowError(`Unable to patch document without an id.`);
-        }
-        const matchedToExisting = (_existing, _data) => {
-          let idMatchedToExisting = null;
-          if (_existing) {
-            for (const identifier of identifiers) {
-              if (_existing[identifier] && _data[identifier] && _existing[identifier] === _data[identifier] || identifier === "_id" && _existing[identifier] === patchId) {
-                idMatchedToExisting = String(identifier);
-                break;
-              }
+      if (!patchId) {
+        uniqueRowError("Unable to patch document without an id.");
+      }
+      const matchedToExisting = (_existing, _data) => {
+        let idMatchedToExisting = null;
+        if (_existing) {
+          for (const identifier of identifiers) {
+            if (_existing[identifier] !== void 0 && _data[identifier] !== void 0 && _existing[identifier] === _data[identifier] || identifier === "_id" && _existing[identifier] === patchId) {
+              idMatchedToExisting = String(identifier);
+              break;
             }
           }
-          return idMatchedToExisting;
-        };
-        const checkExisting = (_existing, _data) => {
-          const matchedId = matchedToExisting(_existing, _data);
-          if (!_existing) {
-            return;
-          }
-          if (matchedId) {
-            return;
-          } else {
-            onFail?.({
-              uniqueRow: {
-                existingData: _existing
-              }
-            });
-            uniqueRowError(
-              `In '${tableName}' table, there already exists a value match of the columns: [${fields.join(`,`)}].`
-            );
-          }
-        };
-        if (!existing && !columnData && patchId) {
-          const match = await ctx.db.get(patchId);
-          if (!match) {
-            uniqueRowError(`No document found for id ${patchId}`);
-            return data;
-          }
-          const extensiveColumnData = constructColumnData(
-            fields,
-            {
-              ...match,
-              ...data
-            },
-            {}
-          );
-          if (extensiveColumnData) {
-            const extensiveExisting = await getExisting(extensiveColumnData);
-            checkExisting(extensiveExisting, data);
-          } else {
-            uniqueRowError(`Incomplete data when there should have been enough.`);
+        }
+        return idMatchedToExisting;
+      };
+      const checkExisting = (_existing, _data) => {
+        const matchedId = matchedToExisting(_existing, _data);
+        if (!_existing || matchedId) {
+          return;
+        }
+        onFail?.({
+          uniqueRow: {
+            existingData: _existing
           }
-        } else {
-          checkExisting(existing, data);
+        });
+        uniqueRowError(
+          `In '${tableName}' table, there already exists a value match of the columns: [${fields.join(",")}].`
+        );
+      };
+      if (!existing && !columnData) {
+        const match = await ctx.db.get(patchId);
+        if (!match) {
+          uniqueRowError(`No document found for id ${patchId}`);
+        }
+        const extensiveColumnData = constructColumnData(
+          fields,
+          {
+            ...match,
+            ...data
+          },
+          {}
+        );
+        if (!extensiveColumnData) {
+          uniqueRowError("Incomplete data when there should have been enough.");
         }
+        const extensiveExisting = await getExisting(extensiveColumnData);
+        checkExisting(extensiveExisting, data);
+        continue;
       }
+      checkExisting(existing, data);
     }
     return data;
-  };
-  return createValidatePlugin("uniqueRow", config, {
-    insert: async (context, data) => {
-      return verifyUniqueness(context, data, context.tableName);
-    },
-    patch: async (context, data) => {
-      return verifyUniqueness(context, data, context.tableName);
-    }
   });
+  return {
+    _type: "uniqueRow",
+    config,
+    verify
+  };
 };
-
-// src/plugins/uniqueColumnConfig.ts
-import { ConvexError as ConvexError2 } from "convex/values";
-var uniqueColumnConfig = (_schema, config) => {
+var buildUniqueColumnVerifier = (config) => {
   const uniqueColumnError = (message) => {
-    throw new ConvexError2({
+    throw new ConvexError({
       message,
       code: "UNIQUE_COLUMN_VERIFICATION_ERROR"
     });
   };
-  const verifyUniqueness = async (context, data) => {
-    const { ctx, tableName, patchId, onFail } = context;
+  const verify = (async (...args) => {
+    const input = args.length === 3 ? {
+      ctx: args[0],
+      tableName: args[1],
+      operation: "insert",
+      data: args[2]
+    } : args.length === 4 ? {
+      ctx: args[0],
+      tableName: args[1],
+      operation: "patch",
+      patchId: args[2],
+      data: args[3]
+    } : args[0];
+    const { ctx, tableName, patchId, onFail, data } = input;
     const tableConfig = config[tableName];
     if (!tableConfig) {
       return data;
@@ -362,7 +308,7 @@ var uniqueColumnConfig = (_schema, config) => {
           isOwnDocument = true;
           break;
         }
-        if (existing[identifier] && data[identifier] && existing[identifier] === data[identifier]) {
+        if (existing[identifier] !== void 0 && data[identifier] !== void 0 && existing[identifier] === data[identifier]) {
           isOwnDocument = true;
           break;
         }
@@ -381,28 +327,239 @@ var uniqueColumnConfig = (_schema, config) => {
       );
     }
     return data;
+  });
+  return {
+    _type: "uniqueColumn",
+    config,
+    verify
+  };
+};
+
+// src/core/plugin.ts
+function createExtension(schemaOrVerify, verify) {
+  const extensionVerify = typeof verify === "function" ? verify : schemaOrVerify;
+  return {
+    _type: "extension",
+    verify(input) {
+      return extensionVerify(input);
+    }
+  };
+}
+function isExtension(value) {
+  return typeof value === "object" && value !== null && "verify" in value && typeof value.verify === "function";
+}
+async function runExtensions(extensions, input) {
+  let verifiedData = input.data;
+  for (const extension of extensions) {
+    verifiedData = await extension.verify({
+      ...input,
+      data: verifiedData
+    });
+  }
+  return verifiedData;
+}
+
+// src/core/verifyConfig.ts
+var verifyConfig = (_schema, configs) => {
+  const builtins = {
+    ...configs.defaultValues ? {
+      defaultValues: buildDefaultValuesVerifier(configs.defaultValues)
+    } : {},
+    ...configs.protectedColumns ? {
+      protectedColumns: buildProtectedColumnsVerifier(configs.protectedColumns)
+    } : {},
+    ...configs.uniqueRow ? {
+      uniqueRow: buildUniqueRowVerifier(
+        _schema,
+        configs.uniqueRow
+      )
+    } : {},
+    ...configs.uniqueColumn ? {
+      uniqueColumn: buildUniqueColumnVerifier(configs.uniqueColumn)
+    } : {}
   };
-  return createValidatePlugin("uniqueColumn", config, {
-    insert: async (context, data) => {
-      return verifyUniqueness(context, data);
-    },
-    patch: async (context, data) => {
-      return verifyUniqueness(context, data);
+  const verify = {
+    ...builtins.defaultValues ? { defaultValues: builtins.defaultValues.verify } : {},
+    ...builtins.protectedColumns ? { protectedColumns: builtins.protectedColumns.verify } : {},
+    ...builtins.uniqueRow ? { uniqueRow: builtins.uniqueRow.verify } : {},
+    ...builtins.uniqueColumn ? { uniqueColumn: builtins.uniqueColumn.verify } : {}
+  };
+  const config = {
+    ...configs.defaultValues ? { defaultValues: configs.defaultValues } : {},
+    ...configs.protectedColumns ? { protectedColumns: configs.protectedColumns } : {},
+    ...configs.uniqueRow ? { uniqueRow: configs.uniqueRow } : {},
+    ...configs.uniqueColumn ? { uniqueColumn: configs.uniqueColumn } : {}
+  };
+  const customExtensions = configs.extensions ?? [];
+  const insert = async (ctx, tableName, data, options) => {
+    let verifiedData = data;
+    if (builtins.defaultValues) {
+      verifiedData = await builtins.defaultValues.verify({
+        ctx,
+        tableName,
+        operation: "insert",
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
     }
-  });
+    if (customExtensions.length > 0) {
+      verifiedData = await runExtensions(customExtensions, {
+        ctx,
+        tableName,
+        operation: "insert",
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    if (builtins.uniqueRow) {
+      verifiedData = await builtins.uniqueRow.verify({
+        ctx,
+        tableName,
+        operation: "insert",
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    if (builtins.uniqueColumn) {
+      verifiedData = await builtins.uniqueColumn.verify({
+        ctx,
+        tableName,
+        operation: "insert",
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    return await ctx.db.insert(tableName, verifiedData);
+  };
+  const patch = async (ctx, tableName, id, data, options) => {
+    let verifiedData = data;
+    const removedProtectedColumns = /* @__PURE__ */ new Set();
+    const stripProtectedColumns = () => {
+      if (!builtins.protectedColumns) {
+        return;
+      }
+      const filtered = stripProtectedPatchColumns(
+        builtins.protectedColumns.config,
+        tableName,
+        verifiedData
+      );
+      for (const column of filtered.removedColumns) {
+        removedProtectedColumns.add(column);
+      }
+      verifiedData = filtered.filteredData;
+    };
+    stripProtectedColumns();
+    if (customExtensions.length > 0) {
+      verifiedData = await runExtensions(customExtensions, {
+        ctx,
+        tableName,
+        operation: "patch",
+        patchId: id,
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    if (builtins.uniqueRow) {
+      verifiedData = await builtins.uniqueRow.verify({
+        ctx,
+        tableName,
+        operation: "patch",
+        patchId: id,
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    if (builtins.uniqueColumn) {
+      verifiedData = await builtins.uniqueColumn.verify({
+        ctx,
+        tableName,
+        operation: "patch",
+        patchId: id,
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    stripProtectedColumns();
+    if (removedProtectedColumns.size > 0) {
+      options?.onFail?.({
+        editableColumn: {
+          removedColumns: [...removedProtectedColumns],
+          filteredData: verifiedData
+        }
+      });
+    }
+    await ctx.db.patch(id, verifiedData);
+  };
+  const dangerouslyPatch = async (ctx, tableName, id, data, options) => {
+    let verifiedData = data;
+    if (customExtensions.length > 0) {
+      verifiedData = await runExtensions(customExtensions, {
+        ctx,
+        tableName,
+        operation: "patch",
+        patchId: id,
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    if (builtins.uniqueRow) {
+      verifiedData = await builtins.uniqueRow.verify({
+        ctx,
+        tableName,
+        operation: "patch",
+        patchId: id,
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    if (builtins.uniqueColumn) {
+      verifiedData = await builtins.uniqueColumn.verify({
+        ctx,
+        tableName,
+        operation: "patch",
+        patchId: id,
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
+    }
+    await ctx.db.patch(id, verifiedData);
+  };
+  return {
+    insert,
+    patch,
+    dangerouslyPatch,
+    verify,
+    config
+  };
 };
+
+// src/core/index.ts
+var createExtension2 = createExtension;
+var isExtension2 = isExtension;
+var runExtensions2 = runExtensions;
+
+// src/index.ts
+var createExtension3 = createExtension2;
+var isExtension3 = isExtension2;
+var runExtensions3 = runExtensions2;
 export {
   constructColumnData,
   constructIndexData,
-  createValidatePlugin,
-  defaultValuesConfig,
+  createExtension3 as createExtension,
   getTableIndexes,
-  isValidatePlugin,
+  isExtension3 as isExtension,
   normalizeIndexConfigEntry,
-  protectedColumnsConfig,
-  runValidatePlugins,
-  uniqueColumnConfig,
-  uniqueRowConfig,
+  runExtensions3 as runExtensions,
   verifyConfig
 };
 //# sourceMappingURL=index.mjs.map