exact-mirror 1.0.2 → 1.1.0

package/dist/cjs/index.d.ts

@@ -57,6 +57,16 @@ export interface Instruction<Emit extends boolean = false> {
     typeCompilerWanred?: boolean;
     modules?: TModule<{}>;
     definitions: Record<string, AnySchema>;
+    /**
+     * Shared cyclic codegen state: generated per-definition mirror
+     * functions, grouped by `$defs` object identity
+     */
+    cyclic: CyclicContext;
+    /**
+     * `$defs` group the current cyclic definition body is generated
+     * against, used to resolve `Ref` nodes to function calls
+     */
+    cyclicDefs?: CyclicGroup;
     recursion: number;
     /**
      * @default 8
@@ -73,6 +83,15 @@ export interface Instruction<Emit extends boolean = false> {
     removeUnknownUnionType: boolean;
 }
 export declare function deepClone<T>(source: T, weak?: WeakMap<object, any>): T;
+interface CyclicGroup {
+    defs: Record<string, AnySchema>;
+    names: Record<string, string>;
+}
+interface CyclicContext {
+    groups: Map<object, CyclicGroup>;
+    fns: string[];
+    count: number;
+}
 export interface Manifest {
     source: string;
     externals: {

package/dist/cjs/index.js

@@ -80,7 +80,7 @@ var handleRecord = (schema, property, instruction) => {
 var handleTuple = (schema, property, instruction) => {
   const i = instruction.array;
   instruction.array++;
-  const isRoot = property === "v" && !instruction.unions.length;
+  const isRoot = property === "v" && !instruction.fromUnion;
   let v = "";
   if (!isRoot) v = `(()=>{`;
   v += `const ar${i}v=[`;
@@ -122,6 +122,59 @@ function deepClone(source, weak = /* @__PURE__ */ new WeakMap()) {
   }
   return source;
 }
+var handleCyclic = (schema, property, instruction) => {
+  const defs = schema.$defs;
+  let group = instruction.cyclic.groups.get(defs);
+  if (!group) {
+    group = { defs, names: {} };
+    instruction.cyclic.groups.set(defs, group);
+    for (const name in defs)
+      group.names[name] = `cy${instruction.cyclic.count++}`;
+    for (const name in defs)
+      instruction.cyclic.fns.push(
+        `function ${group.names[name]}(v){${mirror(defs[name], "v", {
+          ...instruction,
+          cyclicDefs: group,
+          fromUnion: false,
+          parentIsOptional: false,
+          optionals: [],
+          optionalsInArray: [],
+          unionKeys: {},
+          array: 0,
+          recursion: 0
+        })}}`
+      );
+  }
+  const fn = group.names[schema.$ref];
+  if (!fn)
+    throw new Error(
+      `[exact-mirror] cyclic reference "${schema.$ref}" is not found in $defs`
+    );
+  return `(${property}==null?${property}:${fn}(${property}))`;
+};
+var withDefs = (type, group) => {
+  if (Kind in type) {
+    if (type[Kind] === "Cyclic") return type;
+    if (type[Kind] === "Ref" && type.$ref in group.defs)
+      return Object.defineProperty(
+        { $defs: group.defs, $ref: type.$ref },
+        Kind,
+        { value: "Cyclic" }
+      );
+  }
+  let entry = "~check";
+  while (entry in group.defs) entry += "~";
+  const def = Object.create(
+    Object.getPrototypeOf(type),
+    Object.getOwnPropertyDescriptors(type)
+  );
+  def.$id = entry;
+  return Object.defineProperty(
+    { $defs: { ...group.defs, [entry]: def }, $ref: entry },
+    Kind,
+    { value: "Cyclic" }
+  );
+};
 var handleUnion = (schemas, property, instruction) => {
   if (instruction.Compile === void 0) {
     if (!instruction.typeCompilerWanred) {
@@ -143,15 +196,6 @@ var handleUnion = (schemas, property, instruction) => {
     if (!(Kind in type) || !type.$ref) return type;
     if (type[Kind] === "This")
       return deepClone(instruction.definitions[type.$ref]);
-    else if (type[Kind] === "Cyclic") {
-      if (!instruction.modules)
-        console.warn(
-          new Error(
-            "[exact-mirror] modules is required when using nested cyclic reference"
-          )
-        );
-      else return instruction.modules.$defs[type.$ref];
-    }
     return type;
   };
   let cleanThenCheck = "";
@@ -166,7 +210,11 @@ var handleUnion = (schemas, property, instruction) => {
           type.items[i2] = unwrapRef(type.items[i2]);
       else type.items = unwrapRef(type.items);
     }
-    typeChecks.push(instruction.Compile(type));
+    typeChecks.push(
+      instruction.Compile(
+        instruction.cyclicDefs ? withDefs(type, instruction.cyclicDefs) : type
+      )
+    );
     v += `if(d.unions[${ui}][${i}].Check(${property})){return ${mirror(
       type,
       property,
@@ -193,12 +241,31 @@ if(d.unions[${ui}][${i}].Check(tmp))return tmp
 };
 var mirror = (schema, property, instruction) => {
   if (!schema) return "";
-  const isRoot = property === "v" && !instruction.unions.length;
-  if (Kind in schema && schema[Kind] === "~Cyclic" && schema.$ref in schema.$defs)
-    return mirror(schema.$defs[schema.$ref], property, {
-      ...instruction,
-      definitions: Object.assign(instruction.definitions, schema.$defs)
-    });
+  const isRoot = property === "v" && !instruction.fromUnion;
+  const optionalsLength = instruction.optionals.length;
+  try {
+    if (Kind in schema && schema[Kind] === "Cyclic") {
+      const call = handleCyclic(schema, property, instruction);
+      return isRoot ? `return ${call}` : call;
+    }
+    return mirrorNode(schema, property, instruction);
+  } catch (error) {
+    instruction.optionals.length = optionalsLength;
+    console.warn(
+      new Error(
+        "[exact-mirror] failed to generate mirror for a schema node, the node is passed through as-is. Please report this issue to https://github.com/elysiajs/exact-mirror/issues"
+      ),
+      error
+    );
+    return isRoot ? "return v" : property;
+  }
+};
+var mirrorNode = (schema, property, instruction) => {
+  const isRoot = property === "v" && !instruction.fromUnion;
+  if (instruction.cyclicDefs && Kind in schema && schema[Kind] === "Ref" && schema.$ref && schema.$ref in instruction.cyclicDefs.names) {
+    const call = `(${property}==null?${property}:${instruction.cyclicDefs.names[schema.$ref]}(${property}))`;
+    return isRoot ? `return ${call}` : call;
+  }
   if (isRoot && schema.type !== "object" && schema.type !== "array" && !schema.anyOf)
     return `return ${sanitize("v", instruction.sanitize?.length, schema)}`;
   if (instruction.recursion >= instruction.recursionLimit) return property;
@@ -212,6 +279,10 @@ var mirror = (schema, property, instruction) => {
         break;
       }
       schema = mergeObjectIntersection(schema);
+      if (!schema.properties) {
+        v = property;
+        break;
+      }
       v += "{";
       if (schema.additionalProperties) v += `...${property},`;
       const keys = Object.keys(schema.properties);
@@ -270,29 +341,38 @@ var mirror = (schema, property, instruction) => {
       v += "}";
       break;
     case "array":
+      if (!schema.items) {
+        v = property;
+        break;
+      }
       if (
         // @ts-expect-error
         schema.items.type !== "object" && // @ts-expect-error
         schema.items.type !== "array"
       ) {
+        const cyclicItems = instruction.cyclicDefs !== void 0 && !Array.isArray(schema.items) && Kind in schema.items && schema.items[Kind] === "Ref" && schema.items.$ref !== void 0 && schema.items.$ref in instruction.cyclicDefs.names;
         if (Array.isArray(schema.items)) {
           v = handleTuple(schema.items, property, instruction);
           break;
-        } else if (isRoot && !Array.isArray(schema.items.anyOf))
-          return "return v";
-        else if (Kind in schema.items && schema.items.$ref && (schema.items[Kind] === "Ref" || schema.items[Kind] === "This"))
-          v = mirror(
-            deepClone(instruction.definitions[schema.items.$ref]),
-            property,
-            {
-              ...instruction,
-              parentIsOptional: true,
-              recursion: instruction.recursion + 1
-            }
-          );
-        else if (!Array.isArray(schema.items.anyOf)) {
-          v = property;
-          break;
+        } else if (!cyclicItems) {
+          if (isRoot && !Array.isArray(schema.items.anyOf))
+            return "return v";
+          else if (Kind in schema.items && schema.items.$ref && (schema.items[Kind] === "Ref" || schema.items[Kind] === "This"))
+            v = mirror(
+              deepClone(
+                instruction.definitions[schema.items.$ref]
+              ),
+              property,
+              {
+                ...instruction,
+                parentIsOptional: true,
+                recursion: instruction.recursion + 1
+              }
+            );
+          else if (!Array.isArray(schema.items.anyOf)) {
+            v = property;
+            break;
+          }
         }
       }
       const i = instruction.array;
@@ -357,6 +437,7 @@ var createMirror = (schema, {
   emit
 } = {}) => {
   const unions = [];
+  const cyclic = { groups: /* @__PURE__ */ new Map(), fns: [], count: 0 };
   if (typeof sanitize2 === "function") sanitize2 = [sanitize2];
   const f = mirror(schema, "v", {
     optionals: [],
@@ -369,21 +450,23 @@ var createMirror = (schema, {
     modules,
     // @ts-ignore private property
     definitions: definitions ?? modules?.$defs ?? {},
+    cyclic,
     sanitize: sanitize2,
     recursion: 0,
     recursionLimit,
     removeUnknownUnionType
   });
+  const fns = cyclic.fns.length ? cyclic.fns.join("\n") + "\n" : "";
   if (!unions.length && !sanitize2?.length) {
-    if (emit) return { source: f, externals: void 0 };
-    return Function("v", f);
+    if (emit) return { source: fns + f, externals: void 0 };
+    return Function("v", fns + f);
   }
   let hof;
   if (sanitize2?.length) {
     hof = {};
     for (let i = 0; i < sanitize2.length; i++) hof[`h${i}`] = sanitize2[i];
   }
-  const source = `return function mirror(v){${f}}`;
+  const source = `${fns}return function mirror(v){${f}}`;
   if (emit)
     return {
       source,

package/dist/index.d.ts

@@ -57,6 +57,16 @@ export interface Instruction<Emit extends boolean = false> {
     typeCompilerWanred?: boolean;
     modules?: TModule<{}>;
     definitions: Record<string, AnySchema>;
+    /**
+     * Shared cyclic codegen state: generated per-definition mirror
+     * functions, grouped by `$defs` object identity
+     */
+    cyclic: CyclicContext;
+    /**
+     * `$defs` group the current cyclic definition body is generated
+     * against, used to resolve `Ref` nodes to function calls
+     */
+    cyclicDefs?: CyclicGroup;
     recursion: number;
     /**
      * @default 8
@@ -73,6 +83,15 @@ export interface Instruction<Emit extends boolean = false> {
     removeUnknownUnionType: boolean;
 }
 export declare function deepClone<T>(source: T, weak?: WeakMap<object, any>): T;
+interface CyclicGroup {
+    defs: Record<string, AnySchema>;
+    names: Record<string, string>;
+}
+interface CyclicContext {
+    groups: Map<object, CyclicGroup>;
+    fns: string[];
+    count: number;
+}
 export interface Manifest {
     source: string;
     externals: {

package/dist/index.mjs

@@ -53,7 +53,7 @@ var handleRecord = (schema, property, instruction) => {
 var handleTuple = (schema, property, instruction) => {
   const i = instruction.array;
   instruction.array++;
-  const isRoot = property === "v" && !instruction.unions.length;
+  const isRoot = property === "v" && !instruction.fromUnion;
   let v = "";
   if (!isRoot) v = `(()=>{`;
   v += `const ar${i}v=[`;
@@ -95,6 +95,59 @@ function deepClone(source, weak = /* @__PURE__ */ new WeakMap()) {
   }
   return source;
 }
+var handleCyclic = (schema, property, instruction) => {
+  const defs = schema.$defs;
+  let group = instruction.cyclic.groups.get(defs);
+  if (!group) {
+    group = { defs, names: {} };
+    instruction.cyclic.groups.set(defs, group);
+    for (const name in defs)
+      group.names[name] = `cy${instruction.cyclic.count++}`;
+    for (const name in defs)
+      instruction.cyclic.fns.push(
+        `function ${group.names[name]}(v){${mirror(defs[name], "v", {
+          ...instruction,
+          cyclicDefs: group,
+          fromUnion: false,
+          parentIsOptional: false,
+          optionals: [],
+          optionalsInArray: [],
+          unionKeys: {},
+          array: 0,
+          recursion: 0
+        })}}`
+      );
+  }
+  const fn = group.names[schema.$ref];
+  if (!fn)
+    throw new Error(
+      `[exact-mirror] cyclic reference "${schema.$ref}" is not found in $defs`
+    );
+  return `(${property}==null?${property}:${fn}(${property}))`;
+};
+var withDefs = (type, group) => {
+  if (Kind in type) {
+    if (type[Kind] === "Cyclic") return type;
+    if (type[Kind] === "Ref" && type.$ref in group.defs)
+      return Object.defineProperty(
+        { $defs: group.defs, $ref: type.$ref },
+        Kind,
+        { value: "Cyclic" }
+      );
+  }
+  let entry = "~check";
+  while (entry in group.defs) entry += "~";
+  const def = Object.create(
+    Object.getPrototypeOf(type),
+    Object.getOwnPropertyDescriptors(type)
+  );
+  def.$id = entry;
+  return Object.defineProperty(
+    { $defs: { ...group.defs, [entry]: def }, $ref: entry },
+    Kind,
+    { value: "Cyclic" }
+  );
+};
 var handleUnion = (schemas, property, instruction) => {
   if (instruction.Compile === void 0) {
     if (!instruction.typeCompilerWanred) {
@@ -116,15 +169,6 @@ var handleUnion = (schemas, property, instruction) => {
     if (!(Kind in type) || !type.$ref) return type;
     if (type[Kind] === "This")
       return deepClone(instruction.definitions[type.$ref]);
-    else if (type[Kind] === "Cyclic") {
-      if (!instruction.modules)
-        console.warn(
-          new Error(
-            "[exact-mirror] modules is required when using nested cyclic reference"
-          )
-        );
-      else return instruction.modules.$defs[type.$ref];
-    }
     return type;
   };
   let cleanThenCheck = "";
@@ -139,7 +183,11 @@ var handleUnion = (schemas, property, instruction) => {
           type.items[i2] = unwrapRef(type.items[i2]);
       else type.items = unwrapRef(type.items);
     }
-    typeChecks.push(instruction.Compile(type));
+    typeChecks.push(
+      instruction.Compile(
+        instruction.cyclicDefs ? withDefs(type, instruction.cyclicDefs) : type
+      )
+    );
     v += `if(d.unions[${ui}][${i}].Check(${property})){return ${mirror(
       type,
       property,
@@ -166,12 +214,31 @@ if(d.unions[${ui}][${i}].Check(tmp))return tmp
 };
 var mirror = (schema, property, instruction) => {
   if (!schema) return "";
-  const isRoot = property === "v" && !instruction.unions.length;
-  if (Kind in schema && schema[Kind] === "~Cyclic" && schema.$ref in schema.$defs)
-    return mirror(schema.$defs[schema.$ref], property, {
-      ...instruction,
-      definitions: Object.assign(instruction.definitions, schema.$defs)
-    });
+  const isRoot = property === "v" && !instruction.fromUnion;
+  const optionalsLength = instruction.optionals.length;
+  try {
+    if (Kind in schema && schema[Kind] === "Cyclic") {
+      const call = handleCyclic(schema, property, instruction);
+      return isRoot ? `return ${call}` : call;
+    }
+    return mirrorNode(schema, property, instruction);
+  } catch (error) {
+    instruction.optionals.length = optionalsLength;
+    console.warn(
+      new Error(
+        "[exact-mirror] failed to generate mirror for a schema node, the node is passed through as-is. Please report this issue to https://github.com/elysiajs/exact-mirror/issues"
+      ),
+      error
+    );
+    return isRoot ? "return v" : property;
+  }
+};
+var mirrorNode = (schema, property, instruction) => {
+  const isRoot = property === "v" && !instruction.fromUnion;
+  if (instruction.cyclicDefs && Kind in schema && schema[Kind] === "Ref" && schema.$ref && schema.$ref in instruction.cyclicDefs.names) {
+    const call = `(${property}==null?${property}:${instruction.cyclicDefs.names[schema.$ref]}(${property}))`;
+    return isRoot ? `return ${call}` : call;
+  }
   if (isRoot && schema.type !== "object" && schema.type !== "array" && !schema.anyOf)
     return `return ${sanitize("v", instruction.sanitize?.length, schema)}`;
   if (instruction.recursion >= instruction.recursionLimit) return property;
@@ -185,6 +252,10 @@ var mirror = (schema, property, instruction) => {
         break;
       }
       schema = mergeObjectIntersection(schema);
+      if (!schema.properties) {
+        v = property;
+        break;
+      }
       v += "{";
       if (schema.additionalProperties) v += `...${property},`;
       const keys = Object.keys(schema.properties);
@@ -243,29 +314,38 @@ var mirror = (schema, property, instruction) => {
       v += "}";
       break;
     case "array":
+      if (!schema.items) {
+        v = property;
+        break;
+      }
       if (
         // @ts-expect-error
         schema.items.type !== "object" && // @ts-expect-error
         schema.items.type !== "array"
       ) {
+        const cyclicItems = instruction.cyclicDefs !== void 0 && !Array.isArray(schema.items) && Kind in schema.items && schema.items[Kind] === "Ref" && schema.items.$ref !== void 0 && schema.items.$ref in instruction.cyclicDefs.names;
         if (Array.isArray(schema.items)) {
           v = handleTuple(schema.items, property, instruction);
           break;
-        } else if (isRoot && !Array.isArray(schema.items.anyOf))
-          return "return v";
-        else if (Kind in schema.items && schema.items.$ref && (schema.items[Kind] === "Ref" || schema.items[Kind] === "This"))
-          v = mirror(
-            deepClone(instruction.definitions[schema.items.$ref]),
-            property,
-            {
-              ...instruction,
-              parentIsOptional: true,
-              recursion: instruction.recursion + 1
-            }
-          );
-        else if (!Array.isArray(schema.items.anyOf)) {
-          v = property;
-          break;
+        } else if (!cyclicItems) {
+          if (isRoot && !Array.isArray(schema.items.anyOf))
+            return "return v";
+          else if (Kind in schema.items && schema.items.$ref && (schema.items[Kind] === "Ref" || schema.items[Kind] === "This"))
+            v = mirror(
+              deepClone(
+                instruction.definitions[schema.items.$ref]
+              ),
+              property,
+              {
+                ...instruction,
+                parentIsOptional: true,
+                recursion: instruction.recursion + 1
+              }
+            );
+          else if (!Array.isArray(schema.items.anyOf)) {
+            v = property;
+            break;
+          }
         }
       }
       const i = instruction.array;
@@ -330,6 +410,7 @@ var createMirror = (schema, {
   emit
 } = {}) => {
   const unions = [];
+  const cyclic = { groups: /* @__PURE__ */ new Map(), fns: [], count: 0 };
   if (typeof sanitize2 === "function") sanitize2 = [sanitize2];
   const f = mirror(schema, "v", {
     optionals: [],
@@ -342,21 +423,23 @@ var createMirror = (schema, {
     modules,
     // @ts-ignore private property
     definitions: definitions ?? modules?.$defs ?? {},
+    cyclic,
     sanitize: sanitize2,
     recursion: 0,
     recursionLimit,
     removeUnknownUnionType
   });
+  const fns = cyclic.fns.length ? cyclic.fns.join("\n") + "\n" : "";
   if (!unions.length && !sanitize2?.length) {
-    if (emit) return { source: f, externals: void 0 };
-    return Function("v", f);
+    if (emit) return { source: fns + f, externals: void 0 };
+    return Function("v", fns + f);
   }
   let hof;
   if (sanitize2?.length) {
     hof = {};
     for (let i = 0; i < sanitize2.length; i++) hof[`h${i}`] = sanitize2[i];
   }
-  const source = `return function mirror(v){${f}}`;
+  const source = `${fns}return function mirror(v){${f}}`;
   if (emit)
     return {
       source,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "exact-mirror",
-	"version": "1.0.2",
+	"version": "1.1.0",
 	"description": "Mirror exact value to TypeBox/OpenAPI model",
 	"license": "MIT",
 	"scripts": {