convex-verify 1.0.5 → 1.2.2

package/dist/core/index.js

@@ -20,101 +20,548 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/core/index.ts
 var core_exports = {};
 __export(core_exports, {
-  createValidatePlugin: () => createValidatePlugin,
-  isValidatePlugin: () => isValidatePlugin,
+  createExtension: () => createExtension2,
+  isExtension: () => isExtension2,
   normalizeIndexConfigEntry: () => normalizeIndexConfigEntry,
-  runValidatePlugins: () => runValidatePlugins,
+  runExtensions: () => runExtensions2,
+  stripProtectedPatchColumns: () => stripProtectedPatchColumns,
   verifyConfig: () => verifyConfig
 });
 module.exports = __toCommonJS(core_exports);
 
-// 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";
+// src/core/builtins.ts
+var import_values = require("convex/values");
+
+// src/core/types.ts
+function normalizeIndexConfigEntry(entry, defaultIdentifiers = ["_id"]) {
+  if (typeof entry === "string") {
+    return {
+      index: entry,
+      identifiers: defaultIdentifiers
+    };
+  }
+  const { index, identifiers, ...rest } = entry;
+  return {
+    index: String(index),
+    identifiers: identifiers?.map(String) ?? defaultIdentifiers,
+    ...rest
+  };
 }
-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);
+
+// src/utils/helpers.ts
+var getTableIndexes = (schema, tableName) => {
+  return schema.tables[tableName][" indexes"]();
+};
+var constructColumnData = (fields, data, {
+  allowNullishValue = false,
+  allOrNothing = true
+}) => {
+  const lengthOfFields = fields.length;
+  const columnData = fields.map((_, index) => {
+    const column = fields?.[index];
+    const value = data?.[column];
+    if (!column || !allowNullishValue && (value === void 0 || value === null)) {
+      return;
     }
+    return {
+      column,
+      value
+    };
+  }).filter((e) => !!e);
+  if (allOrNothing && columnData.length !== lengthOfFields) {
+    return null;
   }
-  return result;
-}
-function createValidatePlugin(type, config, verify) {
+  return columnData.length > 0 ? columnData : null;
+};
+var constructIndexData = (schema, tableName, indexConfig) => {
+  if (!indexConfig) {
+    return;
+  }
+  const tableConfig = indexConfig?.[tableName];
+  if (!tableConfig) {
+    return;
+  }
+  return tableConfig.map((entry) => {
+    const normalized = normalizeIndexConfigEntry(entry);
+    const { index, identifiers, ...rest } = normalized;
+    const fields = getTableIndexes(schema, tableName).find(
+      (i) => i.indexDescriptor == index
+    )?.fields;
+    if (!fields) {
+      throw new Error(
+        `Error in 'constructIndexData()'. No fields found for index: [${index}]`
+      );
+    }
+    const identifierMap = new Map(
+      [...identifiers, "_id"].map((i) => [String(i), String(i)])
+    );
+    return {
+      name: index,
+      fields,
+      identifiers: Array.from(identifierMap.values()),
+      ...rest
+    };
+  });
+};
+
+// 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 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) {
+      return data;
+    }
+    for (const indexInfo of indexesData) {
+      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 'uniqueColumn' config option.`
+        );
+      }
+      const columnData = constructColumnData(fields, data, {});
+      const getExisting = async (cd) => {
+        let existingByIndex = [];
+        if (cd) {
+          existingByIndex = await ctx.db.query(tableName).withIndex(
+            name,
+            (q) => cd.reduce((query, { column, value }) => query.eq(column, value), q)
+          ).collect();
+        }
+        if (existingByIndex.length > 1) {
+          console.warn(
+            `There was more than one existing result found for index ${name}. Check the following IDs:`,
+            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."
+          );
+        }
+        return existingByIndex.length > 0 ? existingByIndex[0] : null;
+      };
+      const existing = await getExisting(columnData);
+      if (operation === "insert") {
+        if (!existing) {
+          continue;
+        }
+        onFail?.({
+          uniqueRow: {
+            existingData: existing
+          }
+        });
+        uniqueRowError(
+          `Unable to [${operation}] document. In table [${tableName}], there is an existing row that has the same data combination in the columns: [${fields.join(", ")}].`
+        );
+      }
+      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 || matchedId) {
+          return;
+        }
+        onFail?.({
+          uniqueRow: {
+            existingData: _existing
+          }
+        });
+        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 {
+    _type: "uniqueRow",
+    config,
+    verify
+  };
+};
+var buildUniqueColumnVerifier = (config) => {
+  const uniqueColumnError = (message) => {
+    throw new import_values.ConvexError({
+      message,
+      code: "UNIQUE_COLUMN_VERIFICATION_ERROR"
+    });
+  };
+  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;
+    }
+    for (const entry of tableConfig) {
+      const { index, identifiers } = normalizeIndexConfigEntry(
+        entry
+      );
+      const columnName = index.replace("by_", "");
+      const value = data[columnName];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const existing = await ctx.db.query(tableName).withIndex(index, (q) => q.eq(columnName, value)).unique();
+      if (!existing) {
+        continue;
+      }
+      let isOwnDocument = false;
+      for (const identifier of identifiers) {
+        if (identifier === "_id" && patchId && existing._id === patchId) {
+          isOwnDocument = true;
+          break;
+        }
+        if (existing[identifier] !== void 0 && data[identifier] !== void 0 && existing[identifier] === data[identifier]) {
+          isOwnDocument = true;
+          break;
+        }
+      }
+      if (isOwnDocument) {
+        continue;
+      }
+      onFail?.({
+        uniqueColumn: {
+          conflictingColumn: columnName,
+          existingData: existing
+        }
+      });
+      uniqueColumnError(
+        `In [${tableName}] table, there already exists value "${value}" in column [${columnName}].`
+      );
+    }
+    return data;
+  });
   return {
-    _type: type,
+    _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 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 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 (configs.defaultValues) {
-      verifiedData = await configs.defaultValues.verify(
+    if (builtins.defaultValues) {
+      verifiedData = await builtins.defaultValues.verify({
+        ctx,
         tableName,
-        verifiedData
-      );
+        operation: "insert",
+        onFail: options?.onFail,
+        schema: _schema,
+        data: verifiedData
+      });
     }
-    if (validatePlugins.length > 0) {
-      verifiedData = await runValidatePlugins(
-        validatePlugins,
-        {
-          ctx,
-          tableName,
-          operation: "insert",
-          onFail: options?.onFail,
-          schema: _schema
-        },
-        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;
-    if (validatePlugins.length > 0) {
-      verifiedData = await runValidatePlugins(
-        validatePlugins,
-        {
-          ctx,
-          tableName,
-          operation: "patch",
-          patchId: id,
-          onFail: options?.onFail,
-          schema: _schema
-        },
+    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 (validatePlugins.length > 0) {
-      verifiedData = await runValidatePlugins(
-        validatePlugins,
-        {
-          ctx,
-          tableName,
-          operation: "patch",
-          patchId: id,
-          onFail: options?.onFail,
-          schema: _schema
-        },
-        verifiedData
-      );
+    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);
   };
@@ -122,32 +569,22 @@ var verifyConfig = (_schema, configs) => {
     insert,
     patch,
     dangerouslyPatch,
-    // Expose configs for debugging/advanced usage
-    configs
+    verify,
+    config
   };
 };
 
-// src/core/types.ts
-function normalizeIndexConfigEntry(entry, defaultIdentifiers = ["_id"]) {
-  if (typeof entry === "string") {
-    return {
-      index: entry,
-      identifiers: defaultIdentifiers
-    };
-  }
-  const { index, identifiers, ...rest } = entry;
-  return {
-    index: String(index),
-    identifiers: identifiers?.map(String) ?? defaultIdentifiers,
-    ...rest
-  };
-}
+// src/core/index.ts
+var createExtension2 = createExtension;
+var isExtension2 = isExtension;
+var runExtensions2 = runExtensions;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createValidatePlugin,
-  isValidatePlugin,
+  createExtension,
+  isExtension,
   normalizeIndexConfigEntry,
-  runValidatePlugins,
+  runExtensions,
+  stripProtectedPatchColumns,
   verifyConfig
 });
 //# sourceMappingURL=index.js.map