@makehq/forman-schema 1.2.4 → 1.3.0

package/dist/index.cjs

@@ -21,11 +21,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   toFormanSchema: () => toFormanSchema,
-  toJSONSchema: () => toJSONSchema
+  toJSONSchema: () => toJSONSchema,
+  validateForman: () => validateForman,
+  validateFormanWithDomains: () => validateFormanWithDomains
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/utils.ts
+var FORMAN_VISUAL_TYPES = ["banner", "markdown", "html", "separator"];
 function noEmpty(text) {
   return text?.trim() || void 0;
 }
@@ -35,6 +38,35 @@ function isObject(value) {
 function isOptionGroup(value) {
   return "options" in value && Array.isArray(value.options);
 }
+function containsIMLExpression(value) {
+  if (typeof value !== "string") return false;
+  return value.indexOf("{{") > -1 && value.indexOf("}}") > -1;
+}
+var API_ENDPOINTS = {
+  account: "api://connections/{{kind}}",
+  aiagent: "api://ai-agents/v1/agents",
+  datastore: "api://data-stores",
+  hook: "api://hooks/{{kind}}",
+  keychain: "api://keys/{{kind}}",
+  udt: "api://data-structures"
+};
+function normalizeFormanFieldType(field) {
+  const [type, kind] = field.type.split(":");
+  if (!type) return field;
+  if (!(type in API_ENDPOINTS)) return field;
+  let store = isObject(field.options) ? field.options.store : field.options;
+  if (typeof store === "string" || Array.isArray(store)) return field;
+  store = API_ENDPOINTS[type];
+  store = store.replace("/{{kind}}", kind ? `/${kind}` : "");
+  return {
+    ...field,
+    type,
+    options: {
+      ...field.options,
+      store
+    }
+  };
+}
 
 // src/forman.ts
 var SchemaConversionError = class extends Error {
@@ -49,17 +81,13 @@ var SchemaConversionError = class extends Error {
     this.name = "SchemaConversionError";
   }
 };
-var API_ENDPOINTS = {
-  CONNECTIONS: "api://connections",
-  HOOKS: "api://hooks",
-  KEYS: "api://keys"
-};
 var FORMAN_TYPE_MAP = {
   account: "number",
   hook: "number",
   keychain: "number",
   datastore: "number",
   aiagent: "string",
+  udt: "number",
   array: "array",
   collection: "object",
   text: "string",
@@ -98,40 +126,6 @@ function validateFormanField(field) {
     throw new SchemaConversionError(`Unknown field type: ${field.type}`, field);
   }
 }
-function normalizeFieldType(field) {
-  const typeHandlers = {
-    "account:": (type) => ({
-      ...field,
-      type: "account",
-      options: {
-        ...field.options,
-        store: `${API_ENDPOINTS.CONNECTIONS}/${type.substring(8)}`
-      }
-    }),
-    "hook:": (type) => ({
-      ...field,
-      type: "hook",
-      options: {
-        ...field.options,
-        store: `${API_ENDPOINTS.HOOKS}/${type.substring(5)}`
-      }
-    }),
-    "keychain:": (type) => ({
-      ...field,
-      type: "keychain",
-      options: {
-        ...field.options,
-        store: `${API_ENDPOINTS.KEYS}/${type.substring(9)}`
-      }
-    })
-  };
-  for (const [prefix, handler] of Object.entries(typeHandlers)) {
-    if (field.type.startsWith(prefix)) {
-      return handler(field.type);
-    }
-  }
-  return field;
-}
 function appendQueryString(path, domain, tail) {
   if (path.startsWith("api://")) return path;
   const queryString = tail.map((part) => `${encodeURIComponent(part)}={{${part}}}`).join("&");
@@ -152,7 +146,7 @@ function createDefaultContext() {
 }
 function toJSONSchemaInternal(field, context = createDefaultContext()) {
   validateFormanField(field);
-  const normalizedField = normalizeFieldType(field);
+  const normalizedField = normalizeFormanFieldType(field);
   const result = {
     type: FORMAN_TYPE_MAP[normalizedField.type],
     title: noEmpty(normalizedField.label),
@@ -170,6 +164,7 @@ function toJSONSchemaInternal(field, context = createDefaultContext()) {
     case "datastore":
     case "aiagent":
     case "file":
+    case "folder":
       return handleSelectType(normalizedField, result, context);
     default:
       return handlePrimitiveType(normalizedField, result);
@@ -181,6 +176,9 @@ function handleCollectionType(field, result, context) {
     required: []
   });
   function addField(subField, tail) {
+    if (FORMAN_VISUAL_TYPES.includes(subField.type)) {
+      return;
+    }
     if (!subField.name) return;
     if (subField.required) {
       result.required.push(subField.name);
@@ -329,7 +327,7 @@ function handlePrimitiveType(field, result) {
   }
   if (field.validate) {
     if (field.validate.pattern) {
-      result.pattern = field.validate.pattern;
+      result.pattern = typeof field.validate.pattern === "object" ? field.validate.pattern.regexp : field.validate.pattern;
     }
     if (field.validate.min !== void 0) {
       result.minimum = field.validate.min;
@@ -344,6 +342,471 @@ function handlePrimitiveType(field, result) {
   return result;
 }
 
+// src/validator.ts
+var FORMAN_TYPE_MAP2 = {
+  account: "number",
+  hook: "number",
+  keychain: "number",
+  datastore: "number",
+  aiagent: "string",
+  udt: "number",
+  array: "array",
+  collection: "object",
+  text: "string",
+  number: "number",
+  boolean: "boolean",
+  date: "string",
+  json: "string",
+  buffer: "string",
+  cert: "string",
+  color: "string",
+  email: "string",
+  filename: "string",
+  file: "string",
+  folder: "string",
+  hidden: void 0,
+  integer: "number",
+  uinteger: "number",
+  password: "string",
+  path: "string",
+  pkey: "string",
+  port: "number",
+  select: void 0,
+  time: "string",
+  timestamp: "string",
+  timezone: "string",
+  upload: "array",
+  url: "string",
+  uuid: "string",
+  any: void 0
+};
+async function validateFormanWithDomainsInternal(domains, options) {
+  const errors = [];
+  const roots = Object.keys(domains).reduce(
+    (acc, domain) => {
+      acc[domain] = {
+        seenFields: /* @__PURE__ */ new Set(),
+        validateFields: (fields, context) => {
+          return validateFormanValue(
+            domains[domain].values,
+            {
+              name: domain,
+              type: "collection",
+              spec: fields
+            },
+            {
+              ...context,
+              path: [],
+              domain
+            }
+          );
+        }
+      };
+      return acc;
+    },
+    {}
+  );
+  for (const domain of Object.keys(domains)) {
+    if (!domains[domain]) continue;
+    const result = await validateFormanValue(
+      domains[domain].values,
+      {
+        name: domain,
+        type: "collection",
+        spec: domains[domain].schema || []
+      },
+      {
+        roots,
+        domain,
+        path: [],
+        tail: [],
+        strict: options?.strict === true,
+        validateNestedFields: () => {
+          throw new Error("Cannot validate nested fields without parent field.");
+        },
+        resolveRemote: async (path, context) => {
+          if (!options?.resolveRemote) {
+            throw new Error("Remote resource not supported when resolver is not provided.");
+          }
+          const data = context.tail.reduce(
+            (acc, curr) => {
+              acc[curr.name] = curr.value;
+              return acc;
+            },
+            {}
+          );
+          return await options.resolveRemote(path, data);
+        }
+      }
+    );
+    errors.push(...result.errors);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function validateFormanValue(value, field, context) {
+  if (FORMAN_VISUAL_TYPES.includes(field.type)) {
+    return {
+      valid: true,
+      errors: []
+    };
+  }
+  const normalizedField = normalizeFormanFieldType(field);
+  if (normalizedField.required && (value == null || value === "")) {
+    return {
+      valid: false,
+      errors: [
+        {
+          domain: context.domain,
+          path: context.path.join("."),
+          message: "Field is mandatory."
+        }
+      ]
+    };
+  }
+  if (value == null) {
+    return {
+      valid: true,
+      errors: []
+    };
+  }
+  const expectedType = FORMAN_TYPE_MAP2[normalizedField.type];
+  let actualType = typeof value;
+  if (actualType === "object" && Array.isArray(value)) actualType = "array";
+  if (expectedType && expectedType !== actualType) {
+    return {
+      valid: false,
+      errors: [
+        {
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Expected type '${expectedType}', got type '${actualType}'.`
+        }
+      ]
+    };
+  }
+  switch (normalizedField.type) {
+    case "collection":
+      return handleCollectionType2(value, normalizedField, context);
+    case "array":
+      return handleArrayType2(value, normalizedField, context);
+    case "select":
+    case "account":
+    case "hook":
+    case "keychain":
+    case "datastore":
+    case "aiagent":
+    case "file":
+    case "folder":
+      return handleSelectType2(value, normalizedField, context);
+    default:
+      return handlePrimitiveType2(value, normalizedField, context);
+  }
+}
+async function handleCollectionType2(value, field, context) {
+  const errors = [];
+  const seen = context.path.length === 0 ? context.roots[context.domain].seenFields : /* @__PURE__ */ new Set();
+  const path = context.path;
+  if (Array.isArray(field.spec)) {
+    for (const subField of field.spec) {
+      if (FORMAN_VISUAL_TYPES.includes(subField.type)) {
+        continue;
+      }
+      if (!subField.name) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: "Object contains field with unknown name."
+        });
+        continue;
+      }
+      if (context.strict && !seen.has(subField.name)) seen.add(subField.name);
+      const result = await validateFormanValue(value[subField.name], subField, {
+        ...context,
+        path: [...path, subField.name],
+        validateNestedFields: async (fields, context2) => {
+          for (const subField2 of fields) {
+            if (FORMAN_VISUAL_TYPES.includes(subField2.type)) {
+              continue;
+            }
+            if (!subField2.name) {
+              errors.push({
+                domain: context2.domain,
+                path: context2.path.join("."),
+                message: "Object contains field with unknown name."
+              });
+              continue;
+            }
+            if (context2.strict && !seen.has(subField2.name)) seen.add(subField2.name);
+            const result2 = await validateFormanValue(value[subField2.name], subField2, {
+              ...context2,
+              path: [...path, subField2.name]
+            });
+            errors.push(...result2.errors);
+          }
+        }
+      });
+      errors.push(...result.errors);
+    }
+  }
+  if (context.strict) {
+    for (const key of Object.keys(value)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Unknown field '${key}'.`
+        });
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function handleArrayType2(value, field, context) {
+  const errors = [];
+  if (field.spec) {
+    for (const [index, item] of value.entries()) {
+      const result = await validateFormanValue(
+        item,
+        Array.isArray(field.spec) ? { name: index.toString(), type: "collection", spec: field.spec } : Object.assign({}, field.spec, { name: index.toString() }),
+        { ...context, path: [...context.path, index.toString()] }
+      );
+      errors.push(...result.errors);
+    }
+  }
+  if (field.validate) {
+    if (field.validate.minItems !== void 0 && value.length < field.validate.minItems) {
+      errors.push({
+        domain: context.domain,
+        path: context.path.join("."),
+        message: `Array has less than ${field.validate.minItems} items.`
+      });
+    }
+    if (field.validate.maxItems !== void 0 && value.length > field.validate.maxItems) {
+      errors.push({
+        domain: context.domain,
+        path: context.path.join("."),
+        message: `Array has more than ${field.validate.maxItems} items.`
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function handleSelectType2(value, field, context) {
+  const errors = [];
+  let optionsOrGroups = isObject(field.options) ? field.options.store : field.options;
+  let nested = isObject(field.options) ? field.options.nested : void 0;
+  if (typeof optionsOrGroups === "string") {
+    try {
+      optionsOrGroups = await context.resolveRemote(optionsOrGroups, context);
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          ...errors,
+          {
+            domain: context.domain,
+            path: context.path.join("."),
+            message: `Failed to resolve remote resource ${optionsOrGroups}: ${error}`
+          }
+        ]
+      };
+    }
+  }
+  if (field.multiple) {
+    if (!Array.isArray(value)) {
+      return {
+        valid: false,
+        errors: [
+          ...errors,
+          {
+            domain: context.domain,
+            path: context.path.join("."),
+            message: `Value is not an array.`
+          }
+        ]
+      };
+    }
+    for (const singleValue of value) {
+      const found = field.grouped ? optionsOrGroups.some(
+        (group) => group.options.some((option) => option.value === singleValue)
+      ) : optionsOrGroups.some((option) => option.value === singleValue);
+      if (!found) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Value '${singleValue}' not found in options.`
+        });
+      }
+    }
+    if (field.validate) {
+      if (field.validate.minItems !== void 0 && value.length < field.validate.minItems) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Selected less than ${field.validate.minItems} items.`
+        });
+      }
+      if (field.validate.maxItems !== void 0 && value.length > field.validate.maxItems) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Selected more than ${field.validate.maxItems} items.`
+        });
+      }
+    }
+  } else {
+    const item = field.grouped ? optionsOrGroups.find((group) => group.options.some((option) => option.value === value))?.options.find((option) => option.value === value) : optionsOrGroups.find((option) => option.value === value);
+    if (!item) {
+      return {
+        valid: false,
+        errors: [
+          ...errors,
+          {
+            domain: context.domain,
+            path: context.path.join("."),
+            message: `Value '${value}' not found in options.`
+          }
+        ]
+      };
+    }
+    if (item.nested) nested = item.nested;
+  }
+  if (nested) {
+    const result = await handleNestedFields(nested, value, field, context);
+    errors.push(...result.errors);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function handleNestedFields(nested, value, field, context) {
+  const errors = [];
+  let store = isObject(nested) ? nested.store : nested;
+  const domain = isObject(nested) && nested.domain ? nested.domain : void 0;
+  context = {
+    ...context,
+    tail: field.name ? [...context.tail, { name: field.name, value }] : context.tail
+  };
+  if (typeof store === "string") {
+    try {
+      store = await context.resolveRemote(store, context);
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          ...errors,
+          {
+            domain: context.domain,
+            path: context.path.join("."),
+            message: `Failed to resolve remote resource ${store}: ${error}`
+          }
+        ]
+      };
+    }
+  }
+  if (store && domain && domain !== context.domain) {
+    if (!context.roots[domain]) {
+      errors.push({
+        domain: context.domain,
+        path: context.path.join("."),
+        message: `Unable to process nested fields: Domain '${domain}' not found.`
+      });
+    } else {
+      const result = await context.roots[domain].validateFields(store, context);
+      errors.push(...result.errors);
+    }
+  } else if (store) {
+    await context.validateNestedFields(store, context);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+async function handlePrimitiveType2(value, field, context) {
+  const errors = [];
+  if (containsIMLExpression(value)) {
+    return {
+      valid: true,
+      errors
+    };
+  }
+  if (errors.length > 0) {
+    return {
+      valid: false,
+      errors
+    };
+  }
+  if (field.validate) {
+    if (typeof value === "string") {
+      if (field.validate.pattern && !new RegExp(
+        typeof field.validate.pattern === "object" ? field.validate.pattern.regexp : field.validate.pattern
+      ).test(value)) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Value doesn't match the pattern: ${typeof field.validate.pattern === "object" ? field.validate.pattern.regexp : field.validate.pattern}`
+        });
+      }
+      if (field.validate.min !== void 0 && value.length < field.validate.min) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Value must be at least ${field.validate.min} characters long.`
+        });
+      }
+      if (field.validate.max !== void 0 && value.length > field.validate.max) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Value exceeded maximum length of ${field.validate.max} characters.`
+        });
+      }
+      if (field.validate.enum && !field.validate.enum.includes(value)) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: "Value must be one of the following: " + field.validate.enum.join(", ")
+        });
+      }
+    } else if (typeof value === "number") {
+      if (field.validate.min !== void 0 && value < field.validate.min) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Value is too small. Minimum value is ${field.validate.min}.`
+        });
+      }
+      if (field.validate.max !== void 0 && value > field.validate.max) {
+        errors.push({
+          domain: context.domain,
+          path: context.path.join("."),
+          message: `Value is too big. Maximum value is ${field.validate.max}.`
+        });
+      }
+    }
+  }
+  if (field.nested) {
+    const result = await handleNestedFields(field.nested, value, field, context);
+    errors.push(...result.errors);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
 // src/json.ts
 var JSON_PRIMITIVE_TYPE_MAP = {
   string: "text",
@@ -433,8 +896,16 @@ function toFormanSchema(field) {
 function toJSONSchema(field) {
   return toJSONSchemaInternal(field);
 }
+function validateFormanWithDomains(domains, options) {
+  return validateFormanWithDomainsInternal(domains, options);
+}
+function validateForman(values, schema, options) {
+  return validateFormanWithDomains({ default: { values, schema } }, options);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   toFormanSchema,
-  toJSONSchema
+  toJSONSchema,
+  validateForman,
+  validateFormanWithDomains
 });