convex-verify 1.1.0 → 1.2.2

package/dist/index.js

@@ -22,154 +22,17 @@ var src_exports = {};
 __export(src_exports, {
   constructColumnData: () => constructColumnData,
   constructIndexData: () => constructIndexData,
-  createExtension: () => createExtension,
-  defaultValuesConfig: () => defaultValuesConfig,
+  createExtension: () => createExtension3,
   getTableIndexes: () => getTableIndexes,
-  isExtension: () => isExtension,
+  isExtension: () => isExtension3,
   normalizeIndexConfigEntry: () => normalizeIndexConfigEntry,
-  protectedColumnsConfig: () => protectedColumnsConfig,
-  runExtensions: () => runExtensions,
-  uniqueColumnConfig: () => uniqueColumnConfig,
-  uniqueRowConfig: () => uniqueRowConfig,
+  runExtensions: () => runExtensions3,
   verifyConfig: () => verifyConfig
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/core/plugin.ts
-function createExtension(verify) {
-  return {
-    _type: "extension",
-    verify(input) {
-      return verify(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 customExtensions = configs.extensions ?? [];
-  const builtInExtensions = [
-    ...configs.uniqueRow ? [configs.uniqueRow] : [],
-    ...configs.uniqueColumn ? [configs.uniqueColumn] : []
-  ];
-  const extensions = [...customExtensions, ...builtInExtensions];
-  const protectedColumns = configs.protectedColumns?.config ?? {};
-  const stripProtectedPatchColumns = (tableName, data) => {
-    const protectedKeys = protectedColumns[tableName] ?? [];
-    if (protectedKeys.length === 0) {
-      return {
-        filteredData: data,
-        removedColumns: []
-      };
-    }
-    const removedColumns = protectedKeys.filter((key) => key in data).map(String);
-    if (removedColumns.length === 0) {
-      return {
-        filteredData: data,
-        removedColumns
-      };
-    }
-    const filteredData = Object.fromEntries(
-      Object.entries(data).filter(([key]) => !protectedKeys.includes(key))
-    );
-    return {
-      filteredData,
-      removedColumns
-    };
-  };
-  const insert = async (ctx, tableName, data, options) => {
-    let verifiedData = data;
-    if (configs.defaultValues) {
-      verifiedData = await configs.defaultValues.verify(tableName, verifiedData);
-    }
-    if (extensions.length > 0) {
-      verifiedData = await runExtensions(
-        extensions,
-        {
-          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 = () => {
-      const filtered = stripProtectedPatchColumns(tableName, verifiedData);
-      for (const column of filtered.removedColumns) {
-        removedProtectedColumns.add(column);
-      }
-      verifiedData = filtered.filteredData;
-    };
-    stripProtectedColumns();
-    if (extensions.length > 0) {
-      verifiedData = await runExtensions(
-        extensions,
-        {
-          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 (extensions.length > 0) {
-      verifiedData = await runExtensions(
-        extensions,
-        {
-          ctx,
-          tableName,
-          operation: "patch",
-          patchId: id,
-          onFail: options?.onFail,
-          schema: _schema,
-          data: verifiedData
-        }
-      );
-    }
-    await ctx.db.patch(id, verifiedData);
-  };
-  return {
-    insert,
-    patch,
-    dangerouslyPatch
-  };
-};
+// src/core/builtins.ts
+var import_values = require("convex/values");
 
 // src/core/types.ts
 function normalizeIndexConfigEntry(entry, defaultIdentifiers = ["_id"]) {
@@ -187,33 +50,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
-var import_values = require("convex/values");
-
 // src/utils/helpers.ts
 var getTableIndexes = (schema, tableName) => {
   return schema.tables[tableName][" indexes"]();
@@ -226,7 +62,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 {
@@ -270,37 +106,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 import_values.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)
@@ -309,10 +216,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;
@@ -328,95 +235,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] !== void 0 && _data[identifier] !== void 0 && _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;
-  };
-  const extension = {
+  });
+  return {
     _type: "uniqueRow",
     config,
-    async verify(input) {
-      return await verifyUniqueness(
-        input,
-        input.data,
-        input.tableName
-      );
-    }
+    verify
   };
-  return extension;
 };
-
-// src/plugins/uniqueColumnConfig.ts
-var import_values2 = require("convex/values");
-var uniqueColumnConfig = (_schema, config) => {
+var buildUniqueColumnVerifier = (config) => {
   const uniqueColumnError = (message) => {
-    throw new import_values2.ConvexError({
+    throw new import_values.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;
@@ -440,9 +341,7 @@ var uniqueColumnConfig = (_schema, config) => {
           isOwnDocument = true;
           break;
         }
-        const existingValue = existing[identifier];
-        const incomingValue = data[identifier];
-        if (existingValue !== void 0 && incomingValue !== void 0 && existingValue === incomingValue) {
+        if (existing[identifier] !== void 0 && data[identifier] !== void 0 && existing[identifier] === data[identifier]) {
           isOwnDocument = true;
           break;
         }
@@ -461,32 +360,240 @@ var uniqueColumnConfig = (_schema, config) => {
       );
     }
     return data;
-  };
-  const extension = {
+  });
+  return {
     _type: "uniqueColumn",
     config,
-    async verify(input) {
-      return await verifyUniqueness(
-        input,
-        input.data
+    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)
+    } : {}
+  };
+  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
   };
-  return extension;
 };
+
+// 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;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   constructColumnData,
   constructIndexData,
   createExtension,
-  defaultValuesConfig,
   getTableIndexes,
   isExtension,
   normalizeIndexConfigEntry,
-  protectedColumnsConfig,
   runExtensions,
-  uniqueColumnConfig,
-  uniqueRowConfig,
   verifyConfig
 });
 //# sourceMappingURL=index.js.map