🎉 feat: module

Author: SaltyAom

CHANGELOG.md

@@ -1,21 +1,25 @@
-# 0.0.4 - 4 Mar 2024
+# 0.0.5 - 5 Mar 2025
+Feature:
+- support `t.Module`, `t.Ref`
+
+# 0.0.4 - 4 Mar 2025
 Bug fix:
 - handle undefined union
 
-# 0.0.3 - 4 Mar 2024
+# 0.0.3 - 4 Mar 2025
 Bug fix:
 - handle root array
 
-# 0.0.2 - 4 Mar 2024
+# 0.0.2 - 4 Mar 2025
 Feature:
 - support Record, Tuple, Union
 
-# 0.0.1 - 4 Mar 2024
+# 0.0.1 - 4 Mar 2025
 Bug fix:
 - incorrect array bracket limit
 - handle deep nested optional object property
 - using pointer instead of created value for
 
-# 0.0.0 - 4 Mar 2024
+# 0.0.0 - 4 Mar 2025
 Feature:
 - initial release

example/index.ts

@@ -2,21 +2,25 @@ import { t } from 'elysia'
 import { createMirror } from '../src/index'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 
-const shape = t.Union([
-	t.Undefined(),
-	t.Object({
+const v = t.Module({
+	a: t.Object({
 		name: t.String(),
-		job: t.String(),
+		job: t.Optional(t.Ref('job')),
 		trait: t.Optional(t.String())
-	})
-])
+	}),
+	job: t.String()
+})
+
+const shape = v.Import('a')
 
-const value = undefined satisfies typeof shape.static
+const value = {
+	name: 'Jane Doe',
+	job: 'Software Engineer',
+	trait: 'Friendly'
+} satisfies typeof shape.static
 
 const mirror = createMirror(shape, {
 	TypeCompiler
 })
 
-console.dir(mirror(value), {
-	depth: null
-})
+console.log(mirror(value))

package.json

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

src/index.ts

@@ -1,7 +1,9 @@
 import { TypeCompiler, type TypeCheck } from '@sinclair/typebox/compiler'
 import type { TAnySchema, TRecord } from '@sinclair/typebox'
+import { Insert } from '@sinclair/typebox/build/cjs/value'
 
 const Kind = Symbol.for('TypeBox.Kind')
+const OptionalKind = Symbol.for('TypeBox.Optional')
 
 const isSpecialProperty = (name: string) => /(\ |-|\t|\n)/.test(name)
 
@@ -66,6 +68,7 @@ interface Instruction {
 	 */
 	TypeCompiler?: typeof TypeCompiler
 	typeCompilerWanred?: boolean
+	definitions: Record<string, TAnySchema>
 }
 
 const handleRecord = (
@@ -176,6 +179,16 @@ const mirror = (
 
 	const isRoot = property === 'v' && !instruction.unions.length
 
+	if (
+		Kind in schema &&
+		schema[Kind] === 'Import' &&
+		schema.$ref in schema.$defs
+	)
+		return mirror(schema.$defs[schema.$ref], property, {
+			...instruction,
+			definitions: Object.assign(instruction.definitions, schema.$defs)
+		})
+
 	if (
 		isRoot &&
 		schema.type !== 'object' &&
@@ -295,6 +308,13 @@ const mirror = (
 			break
 
 		default:
+			if (schema.$ref && schema.$ref in instruction.definitions)
+				return mirror(
+					instruction.definitions[schema.$ref],
+					property,
+					instruction
+				)
+
 			if (Array.isArray(schema.anyOf)) {
 				v = handleUnion(schema.anyOf, property, instruction)
 
@@ -327,7 +347,10 @@ const mirror = (
 
 export const createMirror = <T extends TAnySchema>(
 	schema: T,
-	{ TypeCompiler }: Pick<Instruction, 'TypeCompiler'> = {}
+	{
+		TypeCompiler,
+		definitions = {}
+	}: Partial<Pick<Instruction, 'TypeCompiler' | 'definitions'>> = {}
 ): ((v: T['static']) => T['static']) => {
 	const unions = <Instruction['unions']>[]
 
@@ -338,7 +361,8 @@ export const createMirror = <T extends TAnySchema>(
 		parentIsOptional: false,
 		unions,
 		unionKeys: {},
-		TypeCompiler
+		TypeCompiler,
+		definitions
 	})
 
 	if (!unions.length) return Function('v', f) as any

test/ref.test.ts

@@ -0,0 +1,102 @@
+import { t } from 'elysia'
+
+import createMirror from '../src'
+
+import { describe, it, expect } from 'bun:test'
+import { isEqual } from './utils'
+
+describe('Ref', () => {
+	it('handle module', () => {
+		const modules = t.Module({
+			object: t.Object({
+				name: t.String(),
+				optional: t.Optional(t.String())
+			})
+		})
+
+		const shape = modules.Import('object')
+
+		const value = {
+			name: 'salt'
+		} satisfies typeof shape.static
+
+		isEqual(shape, value)
+	})
+
+	it('handle nested ref', () => {
+		const modules = t.Module({
+			object: t.Object({
+				name: t.String(),
+				info: t.Ref('info')
+			}),
+			info: t.Object({
+				id: t.Number(),
+				name: t.String()
+			})
+		})
+
+		const shape = modules.Import('object')
+
+		const value = {
+			name: 'salt',
+			info: {
+				id: 123,
+				name: 'salt'
+			}
+		} satisfies typeof shape.static
+
+		isEqual(shape, value)
+	})
+
+	it('handle optional ref', () => {
+		const modules = t.Module({
+			object: t.Object({
+				name: t.String(),
+				info: t.Optional(t.Ref('info'))
+			}),
+			info: t.Object({
+				id: t.Number(),
+				name: t.String()
+			})
+		})
+
+		const shape = modules.Import('object')
+
+		const value = {
+			name: 'salt'
+		} satisfies typeof shape.static
+
+		isEqual(shape, {
+			name: 'salt'
+		})
+
+		isEqual(shape, {
+			name: 'salt',
+			info: {
+				id: 123,
+				name: 'salt'
+			}
+		})
+	})
+
+	it('handle custom modules', () => {
+		const definitions = {
+			object: t.Object({
+				name: t.String(),
+				optional: t.Optional(t.String())
+			})
+		}
+
+		const shape = definitions.object
+
+		const value = {
+			name: 'salt'
+		} satisfies typeof shape.static
+
+		expect(
+			createMirror(shape, {
+				definitions
+			})(value)
+		).toEqual(value)
+	})
+})