@makehq/forman-schema 0.1.4 → 1.1.0

package/README.md

@@ -1 +1,92 @@
-# Forman Schema Tools
+# Forman Schema
+
+A utility for converting between Forman Schema and JSON Schema.
+
+## Installation
+
+```bash
+npm install @makehq/forman-schema
+```
+
+## Usage
+
+### Converting from Forman Schema to JSON Schema
+
+```typescript
+import { toJSONSchema } from '@makehq/forman-schema';
+
+const formanField = {
+    type: 'collection',
+    spec: [
+        {
+            name: 'name',
+            type: 'text',
+            required: true,
+        },
+        {
+            name: 'age',
+            type: 'number',
+        },
+    ],
+};
+
+const jsonSchema = toJSONSchema(formanField);
+```
+
+### Converting from JSON Schema to Forman Schema
+
+```typescript
+import { toFormanSchema } from '@makehq/forman-schema';
+
+const jsonSchemaField = {
+    type: 'object',
+    properties: {
+        name: {
+            type: 'string',
+        },
+        age: {
+            type: 'number',
+        },
+    },
+    required: ['name'],
+};
+
+const formanSchema = toFormanSchema(jsonSchemaField);
+```
+
+## Supported Types
+
+### Forman Schema Types
+
+- text → string
+- number → number
+- boolean → boolean
+- date → string
+- json → string
+- select → string with enum
+- collection → object
+- array → array
+
+### JSON Schema Types
+
+- string → text
+- number → number
+- boolean → boolean
+- object → collection
+- array → array
+
+## Testing
+
+To test the project:
+
+```bash
+npm test
+```
+
+## Building
+
+To build the project:
+
+```bash
+npm run build        # Builds both ESM and CJS versions
+```

package/dist/index.cjs

@@ -24,72 +24,307 @@ __export(index_exports, {
   toJSONSchema: () => toJSONSchema
 });
 module.exports = __toCommonJS(index_exports);
-var FORMAN_PRIMITIVE_TYPE_MAP = {
+
+// src/utils.ts
+function noEmpty(text) {
+  return text?.trim() || void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/forman.ts
+var SchemaConversionError = class extends Error {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    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",
+  array: "array",
+  collection: "object",
   text: "string",
   number: "number",
   boolean: "boolean",
   date: "string",
-  json: "string"
+  json: "string",
+  buffer: "string",
+  cert: "string",
+  color: "string",
+  email: "string",
+  filename: "string",
+  file: "string",
+  folder: "string",
+  hidden: "string",
+  integer: "number",
+  uinteger: "number",
+  password: "string",
+  path: "string",
+  pkey: "string",
+  port: "number",
+  select: "string",
+  time: "string",
+  timestamp: "string",
+  timezone: "string",
+  url: "string",
+  uuid: "string"
 };
-var JSON_PRIMITIVE_TYPE_MAP = {
-  string: "text",
-  number: "number",
-  boolean: "boolean"
-};
-function noEmpty(text) {
-  if (!text) return void 0;
-  return text;
+function validateFormanField(field) {
+  if (!field.type) {
+    throw new SchemaConversionError("Field type is required", field);
+  }
+  const normalizedType = field.type.includes(":") ? field.type.split(":")[0] : field.type;
+  if (!Object.keys(FORMAN_TYPE_MAP).includes(normalizedType)) {
+    throw new SchemaConversionError(`Unknown field type: ${field.type}`, field);
+  }
 }
-function toJSONSchema(field) {
-  switch (field.type) {
+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("&");
+  if (!queryString) return path;
+  const separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}${queryString}`;
+}
+function createDefaultContext() {
+  return {
+    domain: "default",
+    tail: [],
+    path: [],
+    roots: {},
+    addConditionalFields: () => {
+      throw new SchemaConversionError("Cannot serialize nested fields without parent field.");
+    }
+  };
+}
+function toJSONSchemaInternal(field, context = createDefaultContext()) {
+  validateFormanField(field);
+  const normalizedField = normalizeFieldType(field);
+  const result = {
+    type: FORMAN_TYPE_MAP[normalizedField.type] || "string",
+    title: noEmpty(normalizedField.label),
+    description: noEmpty(normalizedField.help)
+  };
+  switch (normalizedField.type) {
     case "collection":
-      const required = [];
-      const properties = (Array.isArray(field.spec) ? field.spec : []).reduce(
-        (object, subField) => {
-          if (!subField.name) return object;
-          if (subField.required) required.push(subField.name);
-          return Object.defineProperty(object, subField.name, {
-            enumerable: true,
-            value: toJSONSchema(subField)
-          });
-        },
-        {}
-      );
-      return {
-        type: "object",
-        description: noEmpty(field.help),
-        properties,
-        required
-      };
+      return handleCollectionType(normalizedField, result, context);
     case "array":
-      return {
-        type: "array",
-        description: noEmpty(field.help),
-        items: field.spec && toJSONSchema(
-          Array.isArray(field.spec) ? {
-            type: "collection",
-            spec: field.spec
-          } : field.spec
-        )
-      };
+      return handleArrayType(normalizedField, result, context);
     case "select":
-      return {
-        type: "string",
-        description: noEmpty(field.help),
-        enum: (field.options || []).map((option) => option.value)
-      };
+    case "account":
+    case "hook":
+    case "keychain":
+    case "datastore":
+    case "aiagent":
+    case "file":
+      return handleSelectType(normalizedField, result, context);
     default:
+      return handlePrimitiveType(normalizedField, result);
+  }
+}
+function handleCollectionType(field, result, context) {
+  Object.assign(result, {
+    type: "object",
+    properties: {},
+    required: []
+  });
+  function addField(subField, tail) {
+    if (!subField.name) return;
+    if (subField.required) {
+      result.required.push(subField.name);
+    }
+    Object.defineProperty(result.properties, subField.name, {
+      enumerable: true,
+      value: toJSONSchemaInternal(subField, {
+        ...context,
+        domain: field["x-domain-root"] || context.domain,
+        tail: tail || context.tail,
+        path: [...context.path, field.name],
+        addConditionalFields: (name, value, nested) => {
+          result.allOf ||= [];
+          result.allOf.push({
+            if: {
+              properties: {
+                [name]: { const: value }
+              }
+            },
+            then: typeof nested === "string" ? { $ref: `${nested}#` } : nested
+          });
+        }
+      })
+    });
+  }
+  if (field["x-domain-root"]) {
+    const domainRoot = field["x-domain-root"];
+    const buffer = context.roots[domainRoot]?.buffer;
+    context.roots[domainRoot] = {
+      addFields: (nested, tail) => {
+        nested.forEach((subField) => addField(subField, tail));
+      }
+    };
+    if (buffer) {
+      buffer.forEach((item) => addField(item.field, item.tail));
+    }
+  }
+  if (Array.isArray(field.spec)) {
+    field.spec.forEach((subField) => addField(subField));
+  }
+  return result;
+}
+function handleArrayType(field, result, context) {
+  if (field.spec) {
+    result.items = toJSONSchemaInternal(
+      Array.isArray(field.spec) ? { type: "collection", spec: field.spec } : field.spec,
+      {
+        ...context,
+        path: [...context.path, `${field.name}[]`]
+      }
+    );
+  }
+  if (field.validate) {
+    if (field.validate.minItems !== void 0) {
+      result.minItems = field.validate.minItems;
+    }
+    if (field.validate.maxItems !== void 0) {
+      result.maxItems = field.validate.maxItems;
+    }
+  }
+  return result;
+}
+function handleSelectType(field, result, context) {
+  const options = isObject(field.options) ? field.options.store : field.options;
+  const nested = isObject(field.options) ? isObject(field.options.nested) ? field.options.nested.store : field.options.nested : void 0;
+  const domain = isObject(field.options) ? isObject(field.options.nested) && field.options.nested.domain ? field.options.nested.domain : void 0 : void 0;
+  if (typeof options === "string") {
+    result["x-fetch"] = appendQueryString(options, context.domain, context.tail);
+  } else if (options?.some((option) => option.label || option.nested)) {
+    result.oneOf = (options || []).map((option) => {
+      const localNested = (isObject(option.nested) ? option.nested.store : option.nested) || nested;
+      const localDomain = (isObject(option.nested) && option.nested.domain ? option.nested.domain : domain) || context.domain;
+      if (localNested) {
+        context.addConditionalFields(
+          field.name,
+          option.value,
+          typeof localNested === "string" ? appendQueryString(localNested, localDomain, [...context.tail, field.name]) : toJSONSchemaInternal(
+            { type: "collection", spec: localNested },
+            {
+              ...context,
+              domain: localDomain,
+              tail: [...context.tail, field.name]
+            }
+          )
+        );
+      }
       return {
-        type: FORMAN_PRIMITIVE_TYPE_MAP[field.type],
-        default: field.default != "" && field.default != null ? field.default : void 0,
-        description: noEmpty(field.help)
+        title: noEmpty(option.label),
+        const: option.value
       };
+    });
+  } else {
+    result.enum = (options || []).map((option) => option.value);
   }
+  if (nested && domain && domain !== context.domain) {
+    if (typeof nested === "string") {
+      throw new SchemaConversionError("Dynamic nested fields with domain change are not supported.");
+    }
+    let root = context.roots[domain];
+    if (!root) {
+      const buffer = [];
+      root = context.roots[domain] = {
+        buffer,
+        addFields: (nested2, tail) => {
+          buffer.push(...nested2.map((field2) => ({ field: field2, tail })));
+        }
+      };
+    }
+    root.addFields(nested, [...context.tail, field.name]);
+  } else if (nested) {
+    result["x-nested"] = typeof nested === "string" ? nested : toJSONSchemaInternal(
+      { type: "collection", spec: nested },
+      {
+        ...context,
+        domain: domain || context.domain,
+        tail: [...context.tail, field.name]
+      }
+    );
+  }
+  return result;
+}
+function handlePrimitiveType(field, result) {
+  if (field.default !== "" && field.default != null) {
+    result.default = field.default;
+  }
+  if (field.validate) {
+    if (field.validate.pattern) {
+      result.pattern = field.validate.pattern;
+    }
+    if (field.validate.min !== void 0) {
+      result.minimum = field.validate.min;
+    }
+    if (field.validate.max !== void 0) {
+      result.maximum = field.validate.max;
+    }
+    if (field.validate.enum) {
+      result.enum = field.validate.enum;
+    }
+  }
+  return result;
 }
+
+// src/json.ts
+var JSON_PRIMITIVE_TYPE_MAP = {
+  string: "text",
+  number: "number",
+  boolean: "boolean"
+};
 function toFormanSchema(field) {
   switch (field.type) {
     case "object":
-      const spec = field.properties ? Object.entries(field.properties).map(([name, property]) => {
+      const spec = field.properties ? Object.entries(field.properties).filter(([name, property]) => !!property).map(([name, property]) => {
         const subField = toFormanSchema(property);
         subField.name = name;
         subField.required = field.required?.includes(name) || false;
@@ -97,41 +332,76 @@ function toFormanSchema(field) {
       }) : [];
       return {
         type: "collection",
-        help: field.description,
+        label: noEmpty(field.title),
+        help: noEmpty(field.description),
         spec
       };
     case "array":
-      return {
+      const items = field.items && isObject(field.items) ? field.items : void 0;
+      const formanSchema = {
         type: "array",
-        help: field.description,
-        spec: field.items && (field.items?.type === "object" && field.items.properties ? Object.entries(field.items.properties).map(([name, property]) => {
+        label: noEmpty(field.title),
+        help: noEmpty(field.description),
+        spec: items ? items.type === "object" && items.properties ? Object.entries(items.properties).map(([name, property]) => {
           const subField = toFormanSchema(property);
           subField.name = name;
-          subField.required = field.items?.required?.includes(name) || false;
+          subField.required = items.required?.includes(name) || false;
           return subField;
-        }) : toFormanSchema(field.items))
+        }) : toFormanSchema(items) : void 0
       };
+      if (field.minItems !== void 0 || field.maxItems !== void 0) {
+        formanSchema.validate = formanSchema.validate || {};
+        if (field.minItems !== void 0) formanSchema.validate.minItems = field.minItems;
+        if (field.maxItems !== void 0) formanSchema.validate.maxItems = field.maxItems;
+      }
+      return formanSchema;
     case "string":
       if (field.enum) {
         return {
           type: "select",
-          help: field.description,
+          label: noEmpty(field.title),
+          help: noEmpty(field.description),
           options: field.enum.map((value) => ({ value }))
         };
+      } else if (field.oneOf) {
+        return {
+          type: "select",
+          label: noEmpty(field.title),
+          help: noEmpty(field.description),
+          options: field.oneOf.filter((value) => value).map((value) => ({ value: value.const }))
+        };
       }
-      return {
+      const textField = {
         type: "text",
-        help: field.description,
+        label: noEmpty(field.title),
+        help: noEmpty(field.description),
         default: field.default
       };
+      if (field.pattern || field.enum) {
+        textField.validate = textField.validate || {};
+        if (field.pattern) textField.validate.pattern = field.pattern;
+        if (field.enum) textField.validate.enum = field.enum;
+      }
+      return textField;
     default:
-      return {
-        type: JSON_PRIMITIVE_TYPE_MAP[field.type],
+      const primitiveField = {
+        type: JSON_PRIMITIVE_TYPE_MAP[field.type] || "text",
         help: field.description,
         default: field.default
       };
+      if (field.minimum !== void 0 || field.maximum !== void 0) {
+        primitiveField.validate = primitiveField.validate || {};
+        if (field.minimum !== void 0) primitiveField.validate.min = field.minimum;
+        if (field.maximum !== void 0) primitiveField.validate.max = field.maximum;
+      }
+      return primitiveField;
   }
 }
+
+// src/index.ts
+function toJSONSchema(field) {
+  return toJSONSchemaInternal(field);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   toFormanSchema,

package/dist/index.d.cts

@@ -1,24 +1,87 @@
+import { JSONSchema7 } from 'json-schema';
+export { JSONSchema7 } from 'json-schema';
+
+/**
+ * Valid Forman Schema field types
+ */
+type FormanSchemaFieldType = 'account' | 'hook' | 'keychain' | 'datastore' | 'aiagent' | 'array' | 'collection' | 'text' | 'number' | 'boolean' | 'date' | 'json' | 'buffer' | 'cert' | 'color' | 'email' | 'filename' | 'file' | 'folder' | 'hidden' | 'integer' | 'uinteger' | 'path' | 'pkey' | 'port' | 'select' | 'time' | 'timestamp' | 'timezone' | 'url' | 'uuid' | `account:${string}` | `hook:${string}` | `keychain:${string}` | string;
+/**
+ * Validation configuration for Forman Schema fields
+ */
+interface FormanSchemaValidation {
+    /** Pattern for string validation */
+    pattern?: string;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Minimum number of items */
+    minItems?: number;
+    /** Maximum number of items */
+    maxItems?: number;
+    /** Enumeration of allowed values */
+    enum?: string[];
+}
+/**
+ * Represents a field in Forman Schema format.
+ */
 type FormanSchemaField = {
+    /** Field name identifier */
     name?: string;
-    type: string;
+    /** The field type (e.g., 'text', 'number', 'boolean', 'collection', 'array', etc.) */
+    type: FormanSchemaFieldType;
+    /** Whether the field is required or not */
     required?: boolean;
-    default?: string | number | boolean | null;
-    options?: {
-        value: string;
-    }[];
+    /** Default value for the field */
+    default?: FormanSchemaValue;
+    /** Available options for select type fields */
+    options?: FormanSchemaOption[] | FormanSchemaExtendedOptions | string;
+    /** Help text or description for the field */
     help?: string;
+    /** Sub-fields specification for collection or array types */
     spec?: FormanSchemaField[] | FormanSchemaField;
+    /** Hide field behind advanced toggle */
+    advanced?: boolean;
+    /** Human readable label for the field */
+    label?: string;
+    /** Nested fields */
+    nested?: FormanSchemaNested;
+    /** Validation rules */
+    validate?: FormanSchemaValidation;
+} & Record<`x-${string}`, unknown>;
+type FormanSchemaValue = string | number | boolean | null;
+type FormanSchemaOption = {
+    /** Option value */
+    value: FormanSchemaValue;
+    /** Option label */
+    label?: string;
+    /** Nested fields for this option */
+    nested?: FormanSchemaNested;
 };
-type JSONSchemaField = {
-    type: string;
-    description?: string;
-    default?: string | number | boolean | null;
-    enum?: string[];
-    properties?: Record<string, JSONSchemaField>;
-    items?: JSONSchemaField;
-    required?: string[];
+type FormanSchemaExtendedOptions = {
+    /** Store for the options */
+    store: FormanSchemaOption[] | string;
+    /** Nested fields for every option */
+    nested?: FormanSchemaNested;
 };
-declare function toJSONSchema(field: FormanSchemaField): JSONSchemaField;
-declare function toFormanSchema(field: JSONSchemaField): FormanSchemaField;
+type FormanSchemaNested = FormanSchemaField[] | string | FormanSchemaExtendedNested;
+type FormanSchemaExtendedNested = {
+    store: FormanSchemaField[] | string;
+    domain?: string;
+};
+
+/**
+ * Converts a JSON Schema field to its Forman Schema equivalent.
+ * @param field The JSON Schema field to convert
+ * @returns The equivalent Forman Schema field
+ */
+declare function toFormanSchema(field: JSONSchema7): FormanSchemaField;
+
+/**
+ * Converts a Forman Schema field to its JSON Schema equivalent.
+ * @param field The Forman Schema field to convert
+ * @returns The equivalent JSON Schema field
+ */
+declare function toJSONSchema(field: FormanSchemaField): JSONSchema7;
 
-export { type FormanSchemaField, type JSONSchemaField, toFormanSchema, toJSONSchema };
+export { type FormanSchemaExtendedNested, type FormanSchemaExtendedOptions, type FormanSchemaField, type FormanSchemaFieldType, type FormanSchemaNested, type FormanSchemaOption, type FormanSchemaValue, toFormanSchema, toJSONSchema };

package/dist/index.d.ts

@@ -1,24 +1,87 @@
+import { JSONSchema7 } from 'json-schema';
+export { JSONSchema7 } from 'json-schema';
+
+/**
+ * Valid Forman Schema field types
+ */
+type FormanSchemaFieldType = 'account' | 'hook' | 'keychain' | 'datastore' | 'aiagent' | 'array' | 'collection' | 'text' | 'number' | 'boolean' | 'date' | 'json' | 'buffer' | 'cert' | 'color' | 'email' | 'filename' | 'file' | 'folder' | 'hidden' | 'integer' | 'uinteger' | 'path' | 'pkey' | 'port' | 'select' | 'time' | 'timestamp' | 'timezone' | 'url' | 'uuid' | `account:${string}` | `hook:${string}` | `keychain:${string}` | string;
+/**
+ * Validation configuration for Forman Schema fields
+ */
+interface FormanSchemaValidation {
+    /** Pattern for string validation */
+    pattern?: string;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Minimum number of items */
+    minItems?: number;
+    /** Maximum number of items */
+    maxItems?: number;
+    /** Enumeration of allowed values */
+    enum?: string[];
+}
+/**
+ * Represents a field in Forman Schema format.
+ */
 type FormanSchemaField = {
+    /** Field name identifier */
     name?: string;
-    type: string;
+    /** The field type (e.g., 'text', 'number', 'boolean', 'collection', 'array', etc.) */
+    type: FormanSchemaFieldType;
+    /** Whether the field is required or not */
     required?: boolean;
-    default?: string | number | boolean | null;
-    options?: {
-        value: string;
-    }[];
+    /** Default value for the field */
+    default?: FormanSchemaValue;
+    /** Available options for select type fields */
+    options?: FormanSchemaOption[] | FormanSchemaExtendedOptions | string;
+    /** Help text or description for the field */
     help?: string;
+    /** Sub-fields specification for collection or array types */
     spec?: FormanSchemaField[] | FormanSchemaField;
+    /** Hide field behind advanced toggle */
+    advanced?: boolean;
+    /** Human readable label for the field */
+    label?: string;
+    /** Nested fields */
+    nested?: FormanSchemaNested;
+    /** Validation rules */
+    validate?: FormanSchemaValidation;
+} & Record<`x-${string}`, unknown>;
+type FormanSchemaValue = string | number | boolean | null;
+type FormanSchemaOption = {
+    /** Option value */
+    value: FormanSchemaValue;
+    /** Option label */
+    label?: string;
+    /** Nested fields for this option */
+    nested?: FormanSchemaNested;
 };
-type JSONSchemaField = {
-    type: string;
-    description?: string;
-    default?: string | number | boolean | null;
-    enum?: string[];
-    properties?: Record<string, JSONSchemaField>;
-    items?: JSONSchemaField;
-    required?: string[];
+type FormanSchemaExtendedOptions = {
+    /** Store for the options */
+    store: FormanSchemaOption[] | string;
+    /** Nested fields for every option */
+    nested?: FormanSchemaNested;
 };
-declare function toJSONSchema(field: FormanSchemaField): JSONSchemaField;
-declare function toFormanSchema(field: JSONSchemaField): FormanSchemaField;
+type FormanSchemaNested = FormanSchemaField[] | string | FormanSchemaExtendedNested;
+type FormanSchemaExtendedNested = {
+    store: FormanSchemaField[] | string;
+    domain?: string;
+};
+
+/**
+ * Converts a JSON Schema field to its Forman Schema equivalent.
+ * @param field The JSON Schema field to convert
+ * @returns The equivalent Forman Schema field
+ */
+declare function toFormanSchema(field: JSONSchema7): FormanSchemaField;
+
+/**
+ * Converts a Forman Schema field to its JSON Schema equivalent.
+ * @param field The Forman Schema field to convert
+ * @returns The equivalent JSON Schema field
+ */
+declare function toJSONSchema(field: FormanSchemaField): JSONSchema7;
 
-export { type FormanSchemaField, type JSONSchemaField, toFormanSchema, toJSONSchema };
+export { type FormanSchemaExtendedNested, type FormanSchemaExtendedOptions, type FormanSchemaField, type FormanSchemaFieldType, type FormanSchemaNested, type FormanSchemaOption, type FormanSchemaValue, toFormanSchema, toJSONSchema };

package/dist/index.js

@@ -1,70 +1,303 @@
-// src/index.ts
-var FORMAN_PRIMITIVE_TYPE_MAP = {
+// src/utils.ts
+function noEmpty(text) {
+  return text?.trim() || void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/forman.ts
+var SchemaConversionError = class extends Error {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    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",
+  array: "array",
+  collection: "object",
   text: "string",
   number: "number",
   boolean: "boolean",
   date: "string",
-  json: "string"
-};
-var JSON_PRIMITIVE_TYPE_MAP = {
-  string: "text",
-  number: "number",
-  boolean: "boolean"
+  json: "string",
+  buffer: "string",
+  cert: "string",
+  color: "string",
+  email: "string",
+  filename: "string",
+  file: "string",
+  folder: "string",
+  hidden: "string",
+  integer: "number",
+  uinteger: "number",
+  password: "string",
+  path: "string",
+  pkey: "string",
+  port: "number",
+  select: "string",
+  time: "string",
+  timestamp: "string",
+  timezone: "string",
+  url: "string",
+  uuid: "string"
 };
-function noEmpty(text) {
-  if (!text) return void 0;
-  return text;
+function validateFormanField(field) {
+  if (!field.type) {
+    throw new SchemaConversionError("Field type is required", field);
+  }
+  const normalizedType = field.type.includes(":") ? field.type.split(":")[0] : field.type;
+  if (!Object.keys(FORMAN_TYPE_MAP).includes(normalizedType)) {
+    throw new SchemaConversionError(`Unknown field type: ${field.type}`, field);
+  }
 }
-function toJSONSchema(field) {
-  switch (field.type) {
+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("&");
+  if (!queryString) return path;
+  const separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}${queryString}`;
+}
+function createDefaultContext() {
+  return {
+    domain: "default",
+    tail: [],
+    path: [],
+    roots: {},
+    addConditionalFields: () => {
+      throw new SchemaConversionError("Cannot serialize nested fields without parent field.");
+    }
+  };
+}
+function toJSONSchemaInternal(field, context = createDefaultContext()) {
+  validateFormanField(field);
+  const normalizedField = normalizeFieldType(field);
+  const result = {
+    type: FORMAN_TYPE_MAP[normalizedField.type] || "string",
+    title: noEmpty(normalizedField.label),
+    description: noEmpty(normalizedField.help)
+  };
+  switch (normalizedField.type) {
     case "collection":
-      const required = [];
-      const properties = (Array.isArray(field.spec) ? field.spec : []).reduce(
-        (object, subField) => {
-          if (!subField.name) return object;
-          if (subField.required) required.push(subField.name);
-          return Object.defineProperty(object, subField.name, {
-            enumerable: true,
-            value: toJSONSchema(subField)
-          });
-        },
-        {}
-      );
-      return {
-        type: "object",
-        description: noEmpty(field.help),
-        properties,
-        required
-      };
+      return handleCollectionType(normalizedField, result, context);
     case "array":
-      return {
-        type: "array",
-        description: noEmpty(field.help),
-        items: field.spec && toJSONSchema(
-          Array.isArray(field.spec) ? {
-            type: "collection",
-            spec: field.spec
-          } : field.spec
-        )
-      };
+      return handleArrayType(normalizedField, result, context);
     case "select":
-      return {
-        type: "string",
-        description: noEmpty(field.help),
-        enum: (field.options || []).map((option) => option.value)
-      };
+    case "account":
+    case "hook":
+    case "keychain":
+    case "datastore":
+    case "aiagent":
+    case "file":
+      return handleSelectType(normalizedField, result, context);
     default:
+      return handlePrimitiveType(normalizedField, result);
+  }
+}
+function handleCollectionType(field, result, context) {
+  Object.assign(result, {
+    type: "object",
+    properties: {},
+    required: []
+  });
+  function addField(subField, tail) {
+    if (!subField.name) return;
+    if (subField.required) {
+      result.required.push(subField.name);
+    }
+    Object.defineProperty(result.properties, subField.name, {
+      enumerable: true,
+      value: toJSONSchemaInternal(subField, {
+        ...context,
+        domain: field["x-domain-root"] || context.domain,
+        tail: tail || context.tail,
+        path: [...context.path, field.name],
+        addConditionalFields: (name, value, nested) => {
+          result.allOf ||= [];
+          result.allOf.push({
+            if: {
+              properties: {
+                [name]: { const: value }
+              }
+            },
+            then: typeof nested === "string" ? { $ref: `${nested}#` } : nested
+          });
+        }
+      })
+    });
+  }
+  if (field["x-domain-root"]) {
+    const domainRoot = field["x-domain-root"];
+    const buffer = context.roots[domainRoot]?.buffer;
+    context.roots[domainRoot] = {
+      addFields: (nested, tail) => {
+        nested.forEach((subField) => addField(subField, tail));
+      }
+    };
+    if (buffer) {
+      buffer.forEach((item) => addField(item.field, item.tail));
+    }
+  }
+  if (Array.isArray(field.spec)) {
+    field.spec.forEach((subField) => addField(subField));
+  }
+  return result;
+}
+function handleArrayType(field, result, context) {
+  if (field.spec) {
+    result.items = toJSONSchemaInternal(
+      Array.isArray(field.spec) ? { type: "collection", spec: field.spec } : field.spec,
+      {
+        ...context,
+        path: [...context.path, `${field.name}[]`]
+      }
+    );
+  }
+  if (field.validate) {
+    if (field.validate.minItems !== void 0) {
+      result.minItems = field.validate.minItems;
+    }
+    if (field.validate.maxItems !== void 0) {
+      result.maxItems = field.validate.maxItems;
+    }
+  }
+  return result;
+}
+function handleSelectType(field, result, context) {
+  const options = isObject(field.options) ? field.options.store : field.options;
+  const nested = isObject(field.options) ? isObject(field.options.nested) ? field.options.nested.store : field.options.nested : void 0;
+  const domain = isObject(field.options) ? isObject(field.options.nested) && field.options.nested.domain ? field.options.nested.domain : void 0 : void 0;
+  if (typeof options === "string") {
+    result["x-fetch"] = appendQueryString(options, context.domain, context.tail);
+  } else if (options?.some((option) => option.label || option.nested)) {
+    result.oneOf = (options || []).map((option) => {
+      const localNested = (isObject(option.nested) ? option.nested.store : option.nested) || nested;
+      const localDomain = (isObject(option.nested) && option.nested.domain ? option.nested.domain : domain) || context.domain;
+      if (localNested) {
+        context.addConditionalFields(
+          field.name,
+          option.value,
+          typeof localNested === "string" ? appendQueryString(localNested, localDomain, [...context.tail, field.name]) : toJSONSchemaInternal(
+            { type: "collection", spec: localNested },
+            {
+              ...context,
+              domain: localDomain,
+              tail: [...context.tail, field.name]
+            }
+          )
+        );
+      }
       return {
-        type: FORMAN_PRIMITIVE_TYPE_MAP[field.type],
-        default: field.default != "" && field.default != null ? field.default : void 0,
-        description: noEmpty(field.help)
+        title: noEmpty(option.label),
+        const: option.value
       };
+    });
+  } else {
+    result.enum = (options || []).map((option) => option.value);
   }
+  if (nested && domain && domain !== context.domain) {
+    if (typeof nested === "string") {
+      throw new SchemaConversionError("Dynamic nested fields with domain change are not supported.");
+    }
+    let root = context.roots[domain];
+    if (!root) {
+      const buffer = [];
+      root = context.roots[domain] = {
+        buffer,
+        addFields: (nested2, tail) => {
+          buffer.push(...nested2.map((field2) => ({ field: field2, tail })));
+        }
+      };
+    }
+    root.addFields(nested, [...context.tail, field.name]);
+  } else if (nested) {
+    result["x-nested"] = typeof nested === "string" ? nested : toJSONSchemaInternal(
+      { type: "collection", spec: nested },
+      {
+        ...context,
+        domain: domain || context.domain,
+        tail: [...context.tail, field.name]
+      }
+    );
+  }
+  return result;
 }
+function handlePrimitiveType(field, result) {
+  if (field.default !== "" && field.default != null) {
+    result.default = field.default;
+  }
+  if (field.validate) {
+    if (field.validate.pattern) {
+      result.pattern = field.validate.pattern;
+    }
+    if (field.validate.min !== void 0) {
+      result.minimum = field.validate.min;
+    }
+    if (field.validate.max !== void 0) {
+      result.maximum = field.validate.max;
+    }
+    if (field.validate.enum) {
+      result.enum = field.validate.enum;
+    }
+  }
+  return result;
+}
+
+// src/json.ts
+var JSON_PRIMITIVE_TYPE_MAP = {
+  string: "text",
+  number: "number",
+  boolean: "boolean"
+};
 function toFormanSchema(field) {
   switch (field.type) {
     case "object":
-      const spec = field.properties ? Object.entries(field.properties).map(([name, property]) => {
+      const spec = field.properties ? Object.entries(field.properties).filter(([name, property]) => !!property).map(([name, property]) => {
         const subField = toFormanSchema(property);
         subField.name = name;
         subField.required = field.required?.includes(name) || false;
@@ -72,41 +305,76 @@ function toFormanSchema(field) {
       }) : [];
       return {
         type: "collection",
-        help: field.description,
+        label: noEmpty(field.title),
+        help: noEmpty(field.description),
         spec
       };
     case "array":
-      return {
+      const items = field.items && isObject(field.items) ? field.items : void 0;
+      const formanSchema = {
         type: "array",
-        help: field.description,
-        spec: field.items && (field.items?.type === "object" && field.items.properties ? Object.entries(field.items.properties).map(([name, property]) => {
+        label: noEmpty(field.title),
+        help: noEmpty(field.description),
+        spec: items ? items.type === "object" && items.properties ? Object.entries(items.properties).map(([name, property]) => {
           const subField = toFormanSchema(property);
           subField.name = name;
-          subField.required = field.items?.required?.includes(name) || false;
+          subField.required = items.required?.includes(name) || false;
           return subField;
-        }) : toFormanSchema(field.items))
+        }) : toFormanSchema(items) : void 0
       };
+      if (field.minItems !== void 0 || field.maxItems !== void 0) {
+        formanSchema.validate = formanSchema.validate || {};
+        if (field.minItems !== void 0) formanSchema.validate.minItems = field.minItems;
+        if (field.maxItems !== void 0) formanSchema.validate.maxItems = field.maxItems;
+      }
+      return formanSchema;
     case "string":
       if (field.enum) {
         return {
           type: "select",
-          help: field.description,
+          label: noEmpty(field.title),
+          help: noEmpty(field.description),
           options: field.enum.map((value) => ({ value }))
         };
+      } else if (field.oneOf) {
+        return {
+          type: "select",
+          label: noEmpty(field.title),
+          help: noEmpty(field.description),
+          options: field.oneOf.filter((value) => value).map((value) => ({ value: value.const }))
+        };
       }
-      return {
+      const textField = {
         type: "text",
-        help: field.description,
+        label: noEmpty(field.title),
+        help: noEmpty(field.description),
         default: field.default
       };
+      if (field.pattern || field.enum) {
+        textField.validate = textField.validate || {};
+        if (field.pattern) textField.validate.pattern = field.pattern;
+        if (field.enum) textField.validate.enum = field.enum;
+      }
+      return textField;
     default:
-      return {
-        type: JSON_PRIMITIVE_TYPE_MAP[field.type],
+      const primitiveField = {
+        type: JSON_PRIMITIVE_TYPE_MAP[field.type] || "text",
         help: field.description,
         default: field.default
       };
+      if (field.minimum !== void 0 || field.maximum !== void 0) {
+        primitiveField.validate = primitiveField.validate || {};
+        if (field.minimum !== void 0) primitiveField.validate.min = field.minimum;
+        if (field.maximum !== void 0) primitiveField.validate.max = field.maximum;
+      }
+      return primitiveField;
   }
 }
+
+// src/index.ts
+function toJSONSchema(field) {
+  return toJSONSchemaInternal(field);
+}
 export {
   toFormanSchema,
   toJSONSchema

package/package.json

@@ -1,14 +1,14 @@
 {
     "name": "@makehq/forman-schema",
-    "version": "0.1.4",
+    "version": "1.1.0",
     "description": "Forman Schema Tools",
     "license": "MIT",
     "author": "Make",
     "repository": "github:integromat/forman-schema",
     "homepage": "https://www.make.com",
     "type": "module",
-    "main": "dist/index.js",
-    "types": "dist/index.d.cts",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.cts",
     "exports": {
         ".": {
             "import": {
@@ -30,13 +30,14 @@
     "scripts": {
         "test": "jest --runInBand --forceExit --verbose false",
         "build": "tsup",
-        "lint": "tsc",
-        "check-exports": "attw --pack .",
-        "format": "npx prettier . --write"
+        "build:version": "node scripts/build-version.mjs",
+        "format": "npx prettier . --write",
+        "publish:jsr": "npx jsr publish --allow-dirty",
+        "lint": "tsc"
     },
     "devDependencies": {
-        "@arethetypeswrong/cli": "^0.17.4",
         "@jest/globals": "^29.7.0",
+        "@types/json-schema": "^7.0.15",
         "@types/node": "^22.13.10",
         "jest": "^29.7.0",
         "prettier": "^3.5.3",