@revisium/schema-toolkit 0.16.5 → 0.17.0

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

@@ -1,4 +1,5 @@
-import { AbstractBasePath, ParsedFormula, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, makeAutoObservable, observable, makeObservable, runInAction, PatchBuilder, SchemaSerializer, FormulaDependencyIndex, createSchemaTree, FormulaSerializer, validateSchema, validateFormulas } from './chunk-7XIWS4W6.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 {
@@ -57,7 +58,7 @@ var SchemaParser = class {
         throw new Error(`Unknown schema type: ${schemaWithType.type}`);
     }
   }
-  parseObject(schema, name, ref) {
+  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];
@@ -67,42 +68,42 @@ var SchemaParser = class {
     }
     return createObjectNode(nanoid(), name, children, {
       metadata: this.extractMetadata(schema),
-      ref
+      ref: ref2
     });
   }
-  parseArray(schema, name, ref) {
+  parseArray(schema, name, ref2) {
     const items = this.parseNode(schema.items, "items");
     return createArrayNode(nanoid(), name, items, {
       metadata: this.extractMetadata(schema),
-      ref
+      ref: ref2
     });
   }
-  parseString(schema, name, ref) {
+  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),
-      ref
+      ref: ref2
     });
   }
-  parseNumber(schema, name, ref) {
+  parseNumber(schema, name, ref2) {
     const nodeId = nanoid();
     this.collectFormula(nodeId, schema["x-formula"]);
     return createNumberNode(nodeId, name, {
       defaultValue: schema.default,
       metadata: this.extractMetadata(schema),
-      ref
+      ref: ref2
     });
   }
-  parseBoolean(schema, name, ref) {
+  parseBoolean(schema, name, ref2) {
     const nodeId = nanoid();
     this.collectFormula(nodeId, schema["x-formula"]);
     return createBooleanNode(nodeId, name, {
       defaultValue: schema.default,
       metadata: this.extractMetadata(schema),
-      ref
+      ref: ref2
     });
   }
   extractMetadata(schema) {
@@ -240,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 {
@@ -249,10 +437,15 @@ 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, this._refSchemas);
     this._currentTree = createSchemaTree(rootNode);
@@ -265,6 +458,7 @@ var SchemaModelImpl = class {
       _serializer: false,
       _nodeFactory: false,
       _formulaIndex: false,
+      _transformChain: false,
       _refSchemas: false,
       _currentTree: "observable.ref",
       _baseTree: "observable.ref",
@@ -308,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);
@@ -2260,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-JHMO5NLL.js.map
-//# sourceMappingURL=chunk-JHMO5NLL.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