@revisium/schema-toolkit 0.16.4 → 0.17.0

package/dist/{chunk-YCJJVI3Z.js → chunk-6EAIJMZV.js}

@@ -1,12 +1,15 @@
-import { AbstractBasePath, ParsedFormula, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, makeAutoObservable, observable, makeObservable, runInAction, PatchBuilder, SchemaSerializer, FormulaDependencyIndex, createSchemaTree, FormulaSerializer, validateSchema, validateFormulas } from './chunk-PGR2S2BR.js';
+import { AbstractBasePath, ParsedFormula, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, makeAutoObservable, observable, makeObservable, runInAction, PatchBuilder, SchemaSerializer, FormulaDependencyIndex, createSchemaTree, FormulaSerializer, validateSchema, validateFormulas } from './chunk-RTBMPBPC.js';
+import { obj, ref } from './chunk-R4CFU33U.js';
 import { nanoid } from 'nanoid';
 
 var SchemaParser = class {
   pendingFormulas = [];
   _parseErrors = [];
-  parse(schema) {
+  _refSchemas = {};
+  parse(schema, refSchemas) {
     this.pendingFormulas = [];
     this._parseErrors = [];
+    this._refSchemas = refSchemas ?? {};
     return this.parseNode(schema, "root");
   }
   parseFormulas(tree) {
@@ -30,27 +33,32 @@ var SchemaParser = class {
   get parseErrors() {
     return this._parseErrors;
   }
-  parseNode(schema, name) {
+  parseNode(schema, name, parentRef) {
     if ("$ref" in schema) {
-      return createRefNode(nanoid(), name, schema.$ref, this.extractMetadata(schema));
+      const refValue = schema.$ref;
+      const resolvedSchema = this._refSchemas[refValue];
+      if (resolvedSchema) {
+        return this.parseNode(resolvedSchema, name, refValue);
+      }
+      return createRefNode(nanoid(), name, refValue, this.extractMetadata(schema));
     }
     const schemaWithType = schema;
     switch (schemaWithType.type) {
       case "object" /* Object */:
-        return this.parseObject(schemaWithType, name);
+        return this.parseObject(schemaWithType, name, parentRef);
       case "array" /* Array */:
-        return this.parseArray(schemaWithType, name);
+        return this.parseArray(schemaWithType, name, parentRef);
       case "string" /* String */:
-        return this.parseString(schemaWithType, name);
+        return this.parseString(schemaWithType, name, parentRef);
       case "number" /* Number */:
-        return this.parseNumber(schemaWithType, name);
+        return this.parseNumber(schemaWithType, name, parentRef);
       case "boolean" /* Boolean */:
-        return this.parseBoolean(schemaWithType, name);
+        return this.parseBoolean(schemaWithType, name, parentRef);
       default:
         throw new Error(`Unknown schema type: ${schemaWithType.type}`);
     }
   }
-  parseObject(schema, name) {
+  parseObject(schema, name, ref2) {
     const children = [];
     for (const propName of Object.keys(schema.properties).sort((a, b) => a.localeCompare(b))) {
       const propSchema = schema.properties[propName];
@@ -58,35 +66,44 @@ var SchemaParser = class {
         children.push(this.parseNode(propSchema, propName));
       }
     }
-    return createObjectNode(nanoid(), name, children, this.extractMetadata(schema));
+    return createObjectNode(nanoid(), name, children, {
+      metadata: this.extractMetadata(schema),
+      ref: ref2
+    });
   }
-  parseArray(schema, name) {
+  parseArray(schema, name, ref2) {
     const items = this.parseNode(schema.items, "items");
-    return createArrayNode(nanoid(), name, items, this.extractMetadata(schema));
+    return createArrayNode(nanoid(), name, items, {
+      metadata: this.extractMetadata(schema),
+      ref: ref2
+    });
   }
-  parseString(schema, name) {
+  parseString(schema, name, ref2) {
     const nodeId = nanoid();
     this.collectFormula(nodeId, schema["x-formula"]);
     return createStringNode(nodeId, name, {
       defaultValue: schema.default,
       foreignKey: schema.foreignKey,
-      metadata: this.extractMetadata(schema)
+      metadata: this.extractMetadata(schema),
+      ref: ref2
     });
   }
-  parseNumber(schema, name) {
+  parseNumber(schema, name, ref2) {
     const nodeId = nanoid();
     this.collectFormula(nodeId, schema["x-formula"]);
     return createNumberNode(nodeId, name, {
       defaultValue: schema.default,
-      metadata: this.extractMetadata(schema)
+      metadata: this.extractMetadata(schema),
+      ref: ref2
     });
   }
-  parseBoolean(schema, name) {
+  parseBoolean(schema, name, ref2) {
     const nodeId = nanoid();
     this.collectFormula(nodeId, schema["x-formula"]);
     return createBooleanNode(nodeId, name, {
       defaultValue: schema.default,
-      metadata: this.extractMetadata(schema)
+      metadata: this.extractMetadata(schema),
+      ref: ref2
     });
   }
   extractMetadata(schema) {
@@ -224,6 +241,193 @@ function generateDefaultValue(schema, options = {}) {
   }
   return generateDefaultValueInternal(schema, options);
 }
+var PrimitiveToArrayTransformer = class {
+  canTransform(ctx) {
+    const { sourceNode, targetSpec } = ctx;
+    return sourceNode.isPrimitive() && targetSpec.type === "array";
+  }
+  transform(ctx) {
+    const { sourceNode } = ctx;
+    const itemsNode = sourceNode.cloneWithId(nanoid());
+    itemsNode.setName("items");
+    const arrayNode = createArrayNode(nanoid(), sourceNode.name(), itemsNode);
+    return { node: arrayNode };
+  }
+};
+var ObjectToArrayTransformer = class {
+  canTransform(ctx) {
+    const { sourceNode, targetSpec } = ctx;
+    return sourceNode.isObject() && targetSpec.type === "array";
+  }
+  transform(ctx) {
+    const { sourceNode } = ctx;
+    const itemsNode = sourceNode.cloneWithId(nanoid());
+    itemsNode.setName("items");
+    const arrayNode = createArrayNode(nanoid(), sourceNode.name(), itemsNode);
+    return { node: arrayNode };
+  }
+};
+var ArrayToItemsTypeTransformer = class {
+  canTransform(ctx) {
+    const { sourceNode, targetSpec } = ctx;
+    if (!sourceNode.isArray()) {
+      return false;
+    }
+    const targetType = targetSpec.type;
+    if (!targetType || !this.isPrimitiveType(targetType)) {
+      return false;
+    }
+    const items = sourceNode.items();
+    return items.nodeType() === targetType;
+  }
+  transform(ctx) {
+    const { sourceNode } = ctx;
+    const items = sourceNode.items();
+    const newNode = items.cloneWithId(nanoid());
+    newNode.setName(sourceNode.name());
+    return { node: newNode };
+  }
+  isPrimitiveType(type) {
+    return type === "string" || type === "number" || type === "boolean";
+  }
+};
+var RefTransformer = class {
+  canTransform(ctx) {
+    return ctx.targetSpec.$ref !== void 0;
+  }
+  transform(ctx) {
+    const { sourceNode, targetSpec, refSchemas } = ctx;
+    const refUri = targetSpec.$ref;
+    const resolvedSchema = refSchemas?.[refUri];
+    if (resolvedSchema) {
+      const parser = new SchemaParser();
+      const wrapperSchema = obj({ temp: ref(refUri) });
+      const resolvedNode = parser.parse(wrapperSchema, refSchemas);
+      const tempNode = resolvedNode.property("temp");
+      const newNode = tempNode.cloneWithId(nanoid());
+      newNode.setName(sourceNode.name());
+      return { node: newNode };
+    }
+    const metadata = this.extractMetadata(targetSpec);
+    const node = createRefNode(nanoid(), sourceNode.name(), refUri, metadata);
+    return { node };
+  }
+  extractMetadata(spec) {
+    const meta = {};
+    let hasValue = false;
+    if (spec.title) {
+      meta.title = spec.title;
+      hasValue = true;
+    }
+    if (spec.description) {
+      meta.description = spec.description;
+      hasValue = true;
+    }
+    if (spec.deprecated) {
+      meta.deprecated = spec.deprecated;
+      hasValue = true;
+    }
+    return hasValue ? meta : void 0;
+  }
+};
+var DefaultTransformer = class {
+  canTransform(ctx) {
+    return ctx.targetSpec.type !== void 0;
+  }
+  transform(ctx) {
+    const { sourceNode, targetSpec } = ctx;
+    const type = targetSpec.type;
+    const metadata = this.extractMetadata(targetSpec);
+    const node = this.createNode(sourceNode.name(), type, targetSpec, metadata);
+    return { node };
+  }
+  createNode(name, type, spec, metadata) {
+    switch (type) {
+      case "string":
+        return createStringNode(nanoid(), name, {
+          defaultValue: spec.default ?? "",
+          foreignKey: spec.foreignKey,
+          metadata
+        });
+      case "number":
+        return createNumberNode(nanoid(), name, {
+          defaultValue: spec.default ?? 0,
+          metadata
+        });
+      case "boolean":
+        return createBooleanNode(nanoid(), name, {
+          defaultValue: spec.default ?? false,
+          metadata
+        });
+      case "object":
+        return createObjectNode(nanoid(), name, [], { metadata });
+      case "array":
+        return this.createArrayNode(name, metadata);
+      default:
+        throw new Error(`Unknown field type: ${type}`);
+    }
+  }
+  createArrayNode(name, metadata) {
+    const items = createStringNode(nanoid(), "items", { defaultValue: "" });
+    return createArrayNode(nanoid(), name, items, { metadata });
+  }
+  extractMetadata(spec) {
+    const meta = {};
+    let hasValue = false;
+    if (spec.title) {
+      meta.title = spec.title;
+      hasValue = true;
+    }
+    if (spec.description) {
+      meta.description = spec.description;
+      hasValue = true;
+    }
+    if (spec.deprecated) {
+      meta.deprecated = spec.deprecated;
+      hasValue = true;
+    }
+    return hasValue ? meta : void 0;
+  }
+};
+
+// src/model/type-transformer/TypeTransformChain.ts
+var TypeTransformChain = class {
+  _transformers;
+  _refSchemas;
+  constructor(options = {}) {
+    this._refSchemas = options.refSchemas;
+    this._transformers = [
+      ...options.customTransformers ?? [],
+      new PrimitiveToArrayTransformer(),
+      new ObjectToArrayTransformer(),
+      new ArrayToItemsTypeTransformer(),
+      new RefTransformer(),
+      new DefaultTransformer()
+    ];
+  }
+  transform(sourceNode, spec) {
+    const normalizedSpec = this.normalizeSpec(spec);
+    const ctx = {
+      sourceNode,
+      targetSpec: normalizedSpec,
+      refSchemas: this._refSchemas
+    };
+    const transformer = this._transformers.find((t) => t.canTransform(ctx));
+    if (!transformer) {
+      throw new Error(`No transformer found for spec: ${JSON.stringify(spec)}`);
+    }
+    return transformer.transform(ctx);
+  }
+  normalizeSpec(spec) {
+    if (typeof spec === "string") {
+      return { type: spec };
+    }
+    return spec;
+  }
+};
+function createTypeTransformChain(options) {
+  return new TypeTransformChain(options);
+}
 
 // src/model/schema-model/SchemaModelImpl.ts
 var SchemaModelImpl = class {
@@ -233,22 +437,28 @@ var SchemaModelImpl = class {
   _serializer = new SchemaSerializer();
   _nodeFactory = new NodeFactory();
   _formulaIndex = new FormulaDependencyIndex();
+  _transformChain;
   _formulaParseErrors = [];
   _refSchemas;
   constructor(schema, options) {
+    this._refSchemas = options?.refSchemas;
+    this._transformChain = new TypeTransformChain({
+      refSchemas: this._refSchemas,
+      customTransformers: options?.customTransformers
+    });
     const parser = new SchemaParser();
-    const rootNode = parser.parse(schema);
+    const rootNode = parser.parse(schema, this._refSchemas);
     this._currentTree = createSchemaTree(rootNode);
     parser.parseFormulas(this._currentTree);
     this._formulaParseErrors = parser.parseErrors;
     this._buildFormulaIndex();
     this._baseTree = this._currentTree.clone();
-    this._refSchemas = options?.refSchemas;
     makeAutoObservable(this, {
       _patchBuilder: false,
       _serializer: false,
       _nodeFactory: false,
       _formulaIndex: false,
+      _transformChain: false,
       _refSchemas: false,
       _currentTree: "observable.ref",
       _baseTree: "observable.ref",
@@ -292,10 +502,10 @@ var SchemaModelImpl = class {
     if (path.isEmpty()) {
       return node;
     }
-    const newNode = this._nodeFactory.createNode(node.name(), newType);
-    this._currentTree.setNodeAt(path, newNode);
-    this._currentTree.trackReplacement(nodeId, newNode.id());
-    return newNode;
+    const result = this._transformChain.transform(node, newType);
+    this._currentTree.setNodeAt(path, result.node);
+    this._currentTree.trackReplacement(nodeId, result.node.id());
+    return result.node;
   }
   updateMetadata(nodeId, meta) {
     const node = this._currentTree.nodeById(nodeId);
@@ -2244,6 +2454,6 @@ function createDataModel(options) {
   return new DataModelImpl(options);
 }
 
-export { ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, NodeFactory, NodeFactory2, NodeFactoryRegistry, NumberValueNode, ObjectValueNode, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createSchemaModel, createTableModel, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter };
-//# sourceMappingURL=chunk-YCJJVI3Z.js.map
-//# sourceMappingURL=chunk-YCJJVI3Z.js.map
+export { ArrayToItemsTypeTransformer, ArrayValueNode, BasePrimitiveValueNode, BaseValueNode, BooleanValueNode, DataModelImpl, DefaultTransformer, ForeignKeyNotFoundError, ForeignKeyResolverImpl, ForeignKeyResolverNotConfiguredError, ForeignKeyValueNodeImpl, NodeFactory, NodeFactory2, NodeFactoryRegistry, NumberValueNode, ObjectToArrayTransformer, ObjectValueNode, PrimitiveToArrayTransformer, RefTransformer, RowModelImpl, SchemaParser, StringValueNode, TableModelImpl, TypeTransformChain, ValueType, createDataModel, createDefaultRegistry, createForeignKeyResolver, createNodeFactory, createSchemaModel, createTableModel, createTypeTransformChain, extractFormulaDefinition, generateDefaultValue, generateNodeId, isForeignKeyValueNode, resetNodeIdCounter };
+//# sourceMappingURL=chunk-6EAIJMZV.js.map
+//# sourceMappingURL=chunk-6EAIJMZV.js.map