@wovin/core 0.2.2 → 0.3.0

package/src/viewmodel/adapters/typebox.ts

@@ -0,0 +1,59 @@
+import type { ApplogValue } from '../../applog/datom-types.ts'
+import type { ISchemaAdapter, VMAttributeDef } from '../types.ts'
+
+/**
+ * Create a schema adapter from a TypeBox object schema.
+ *
+ * Usage:
+ * ```ts
+ * import { Type } from '@sinclair/typebox'
+ * import { createTypeBoxAdapter } from '@wovin/core/viewmodel/adapters/typebox'
+ *
+ * const MySchema = Type.Object({
+ *   name: Type.String(),
+ *   age: Type.Optional(Type.Number()),
+ * })
+ *
+ * const adapter = createTypeBoxAdapter(MySchema, 'myEntity')
+ * ```
+ *
+ * The type parameter `T` is the inferred static type of the schema.
+ * Can pass a compiled validator separately if runtime validation is needed.
+ */
+export function createTypeBoxAdapter<T extends Record<string, ApplogValue>>(
+	typeBoxSchema: { properties: Record<string, any>; type?: string },
+	entityPrefix: string,
+	options?: {
+		/** Override at-paths for specific attributes */
+		atOverrides?: Record<string, string>
+		/** Default values */
+		defaults?: Partial<T>
+		/** Property name to at-path mapping function */
+		toAtPath?: (entityPrefix: string, attrName: string) => string
+		/** A pre-compiled validator function (e.g. from TypeCompiler.Compile) */
+		validator?: (value: unknown) => value is T
+	},
+): ISchemaAdapter<T> {
+	const properties = typeBoxSchema.properties as Record<string, any>
+	const toAtPath = options?.toAtPath ?? ((prefix, name) => `${prefix}/${name}`)
+
+	const attributeDefs: VMAttributeDef[] = Object.entries(properties).map(([name, propSchema]: [string, any]) => {
+		const isOptional = propSchema.optional ?? false
+		const wovinAtName = propSchema.wovinAtName
+		const atPath = options?.atOverrides?.[name] ?? wovinAtName ?? toAtPath(entityPrefix, name)
+
+		return {
+			name,
+			atPath,
+			optional: isOptional,
+			defaultValue: propSchema.default,
+		}
+	})
+
+	return {
+		getAttributeDefs: () => attributeDefs,
+		getDefaults: () => (options?.defaults ?? {}) as Partial<T>,
+		getEntityPrefix: () => entityPrefix,
+		createValidator: options?.validator ? () => options.validator! : undefined,
+	}
+}

package/src/viewmodel/adapters/typia.ts

@@ -0,0 +1,50 @@
+import type { ApplogValue } from '../../applog/datom-types.ts'
+import type { ISchemaAdapter, VMAttributeDef } from '../types.ts'
+
+/**
+ * Pattern for creating a schema adapter from a Typia-generated schema.
+ *
+ * Typia is NOT a runtime dependency of @wovin/core, so this adapter
+ * works by accepting the Typia type object directly along with the
+ * attribute definitions (which must be provided separately since
+ * Typia doesn't expose runtime property introspection by default).
+ *
+ * Usage:
+ * ```ts
+ * import typia from 'typia'
+ * import { createTypiaAdapter } from '@wovin/core/viewmodel/adapters/typia'
+ *
+ * interface MyEntity { name: string; age?: number }
+ *
+ * const adapter = createTypiaAdapter<MyEntity>(
+ *   typia.createValidate<MyEntity>(),
+ *   'myEntity',
+ *   {
+ *     attributes: [
+ *       { name: 'name', atPath: 'myEntity/name', optional: false },
+ *       { name: 'age', atPath: 'myEntity/age', optional: true },
+ *     ],
+ *   },
+ * )
+ * ```
+ */
+export function createTypiaAdapter<T extends Record<string, ApplogValue>>(
+	_typiaValidator: (input: unknown) => { success: boolean; data: T | null; errors?: any[] },
+	entityPrefix: string,
+	options: {
+		/** Attribute definitions (required for Typia since property introspection is compile-time) */
+		attributes: VMAttributeDef[]
+		/** Default values */
+		defaults?: Partial<T>
+	},
+): ISchemaAdapter<T> {
+	return {
+		getAttributeDefs: () => options.attributes,
+		getDefaults: () => (options?.defaults ?? {}) as Partial<T>,
+		getEntityPrefix: () => entityPrefix,
+		createValidator: () => (value: unknown): value is T => {
+			const result = _typiaValidator(value)
+			return result.success
+		},
+	}
+}

package/src/viewmodel/adapters/zod.ts

@@ -0,0 +1,55 @@
+import type { ApplogValue } from '../../applog/datom-types.ts'
+import type { ISchemaAdapter, VMAttributeDef } from '../types.ts'
+import type { ZodObject, ZodType, ZodTypeAny } from 'zod'
+
+/**
+ * Create a schema adapter from a Zod object schema.
+ *
+ * Usage:
+ * ```ts
+ * import { z } from 'zod'
+ * import { createZodAdapter } from '@wovin/core/viewmodel/adapters/zod'
+ *
+ * const MySchema = z.object({
+ *   name: z.string(),
+ *   age: z.number().optional(),
+ * })
+ *
+ * const adapter = createZodAdapter(MySchema, 'myEntity')
+ * ```
+ *
+ * The type parameter `T` is the inferred type of the schema.
+ */
+export function createZodAdapter<T extends Record<string, ApplogValue> = Record<string, ApplogValue>>(
+	zodSchema: ZodObject<Record<string, ZodTypeAny>>,
+	entityPrefix: string,
+	options?: {
+		/** Override at-paths for specific attributes */
+		atOverrides?: Record<string, string>
+		/** Default values */
+		defaults?: Partial<T>
+		/** Property name to at-path mapping function */
+		toAtPath?: (entityPrefix: string, attrName: string) => string
+	},
+): ISchemaAdapter<T> {
+	const shape = zodSchema.shape as Record<string, ZodTypeAny>
+	const toAtPath = options?.toAtPath ?? ((prefix, name) => `${prefix}/${name}`)
+
+	const attributeDefs: VMAttributeDef[] = Object.entries(shape).map(([name, fieldSchema]: [string, ZodTypeAny]) => {
+		const isOptional = fieldSchema.isOptional() || fieldSchema.isNullable()
+		const atPath = options?.atOverrides?.[name] ?? toAtPath(entityPrefix, name)
+
+		return {
+			name,
+			atPath,
+			optional: isOptional,
+		}
+	})
+
+	return {
+		getAttributeDefs: () => attributeDefs,
+		getDefaults: () => (options?.defaults ?? {}) as Partial<T>,
+		getEntityPrefix: () => entityPrefix,
+		createValidator: () => (value: unknown): value is T => zodSchema.safeParse(value).success,
+	}
+}

package/src/viewmodel/builder.ts

@@ -0,0 +1,71 @@
+import type { ApplogForInsertOptionalAgent, ApplogValue, EntityID } from '../applog/datom-types.ts'
+
+/**
+ * Generic ObjectBuilder for type-safe entity creation and updates.
+ *
+ * Provides a fluent API to build a set of applogs for an entity.
+ * Modeled after the note3 builder pattern.
+ *
+ * Usage:
+ * ```ts
+ * ObjectBuilder.create({ name: 'foo' })
+ *   .update({ type: 'bar' })
+ *   .build(thread)
+ * ```
+ */
+export class ObjectBuilder<
+	TARGET extends Record<string, ApplogValue> = Record<string, ApplogValue>,
+> {
+	constructor(
+		private _data: Partial<TARGET>,
+		public en: EntityID | null = null,
+		private _atPrefix: string | null = null,
+		private _atOverrides: Partial<Record<keyof TARGET, string>> = {},
+	) {}
+
+	/**
+	 * Create a new builder with initial data.
+	 */
+	static create<TARGET extends Record<string, ApplogValue>>(
+		init: Partial<TARGET> = {},
+		en?: EntityID,
+		atPrefix?: string,
+		atOverrides?: Partial<Record<keyof TARGET, string>>,
+	): ObjectBuilder<TARGET> {
+		return new ObjectBuilder<TARGET>(init, en, atPrefix, atOverrides)
+	}
+
+	/**
+	 * Update the data being built.
+	 */
+	update(updateObj: Partial<TARGET>): this {
+		Object.assign(this._data, updateObj)
+		return this
+	}
+
+	/**
+	 * Build the applogs for this entity, optionally resolving against a thread.
+	 */
+	build(thread?: {
+		insert(applogs: ApplogForInsertOptionalAgent[]): ApplogForInsertOptionalAgent[]
+	}): ApplogForInsertOptionalAgent[] {
+		const atPrefix = this._atPrefix
+		const applogs: ApplogForInsertOptionalAgent[] = []
+
+		for (const [key, value] of Object.entries(this._data) as [keyof TARGET, ApplogValue][]) {
+			if (value === undefined) continue
+			const atOverride = this._atOverrides[key]
+			const at = atOverride ?? (atPrefix ? `${atPrefix}/${String(key)}` : String(key))
+			applogs.push({ en: this.en!, at, vl: value })
+		}
+
+		return applogs
+	}
+
+	/**
+	 * Get the raw data being built.
+	 */
+	get data(): Partial<TARGET> {
+		return { ...this._data }
+	}
+}

package/src/viewmodel/examples/all-adapters.ts

@@ -0,0 +1,206 @@
+/**
+ * ═══════════════════════════════════════════════════════════════
+ * Schema Adapter Examples
+ * ═══════════════════════════════════════════════════════════════
+ *
+ * This file demonstrates how to use each schema adapter with the
+ * generic ViewModel factory. Uncomment the adapter you want to use.
+ *
+ * Each section is self-contained and shows:
+ * 1. Schema definition
+ * 2. Adapter creation
+ * 3. ViewModel factory usage
+ * 4. Basic VM usage
+ *
+ * Note: Not all schema libraries are installed as dependencies.
+ *   ✓ TypeBox — peer dependency of @wovin/core (available)
+ *   ✓ Zod — dependency of @wovin/core (available)
+ *   ✗ ArkType — NOT installed (example shown for pattern reference)
+ *   ✗ Typia — NOT installed (example shown for pattern reference)
+ */
+
+import { createViewModelFactory, ObjectBuilder, type ISchemaAdapter, type VMAttributeDef } from '../index.ts'
+import type { Thread } from '../../thread/basic.ts'
+import type { ApplogValue, EntityID } from '../../applog/datom-types.ts'
+
+// ═══════════════════════════════════════════════════════════════
+// Shared helpers for examples
+// ═══════════════════════════════════════════════════════════════
+
+/** Dummy thread for examples */
+function createMockThread(): Thread {
+	return { name: 'mock', applogs: [], filters: [], subscribe: () => () => {} } as unknown as Thread
+}
+
+interface Note extends Record<string, ApplogValue> {
+	title: string
+	body: string
+	tags?: string
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 1. TypeBox Adapter Example
+// ═══════════════════════════════════════════════════════════════
+
+// import { Type } from '@sinclair/typebox'
+// import { Static } from '@sinclair/typebox'
+// import { createTypeBoxAdapter } from '../adapters/typebox.ts'
+
+export function typeBoxExample() {
+	/*
+
+	const NoteSchema = Type.Object({
+		title: Type.String(),
+		body: Type.String(),
+		tags: Type.Optional(Type.String()),
+	})
+	type Note = Static<typeof NoteSchema>
+
+	const NoteVM = createViewModelFactory<Note>({
+		adapter: createTypeBoxAdapter(NoteSchema, 'note', {
+			atOverrides: {
+				title: 'note/title',
+				body: 'note/body',
+				tags: 'note/tags',
+			},
+		}),
+		vmName: 'Note',
+	})
+
+	const thread = createMockThread()
+	const note = NoteVM.get('abc123' as EntityID, thread)
+	console.log(note.title) // reactive read
+	note.title = 'Hello'   // writes to thread via applog
+
+	*/
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 2. Zod Adapter Example
+// ═══════════════════════════════════════════════════════════════
+
+// import { z } from 'zod'
+// import { createZodAdapter } from '../adapters/zod.ts'
+
+export function zodExample() {
+	/*
+
+	const NoteSchema = z.object({
+		title: z.string(),
+		body: z.string(),
+		tags: z.string().optional(),
+	})
+	type Note = z.infer<typeof NoteSchema>
+
+	const NoteVM = createViewModelFactory<Note>({
+		adapter: createZodAdapter(NoteSchema, 'note', {
+			atOverrides: {
+				title: 'note/title',
+				body: 'note/body',
+				tags: 'note/tags',
+			},
+		}),
+		vmName: 'Note',
+	})
+
+	const thread = createMockThread()
+	const note = NoteVM.get('abc123' as EntityID, thread)
+	console.log(note.title)
+	note.title = 'Hello'
+
+	*/
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 3. ArkType Adapter Pattern
+// ═══════════════════════════════════════════════════════════════
+// ArkType is NOT a dependency. This shows the pattern if you install it.
+
+// import { createArkTypeAdapter } from '../adapters/arktype.ts'
+
+export function arkTypePattern() {
+	/*
+
+	// First, define attributes manually (ArkType doesn't expose runtime props)
+	const attrs: VMAttributeDef[] = [
+		{ name: 'title', atPath: 'note/title', optional: false },
+		{ name: 'body', atPath: 'note/body', optional: false },
+		{ name: 'tags', atPath: 'note/tags', optional: true },
+	]
+
+	// Then create the adapter with a validator
+	// import { type } from 'arktype'
+	// const NoteSchema = type({ title: 'string', body: 'string', 'tags?': 'string' })
+
+	const NoteVM = createViewModelFactory<Note>({
+		adapter: createArkTypeAdapter(
+			// NoteSchema, // your arktype validator
+			{} as any, // placeholder
+			'note',
+			{ attributes: attrs },
+		),
+		vmName: 'Note',
+	})
+
+	*/
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 4. Typia Adapter Pattern
+// ═══════════════════════════════════════════════════════════════
+// Typia is NOT a dependency. This shows the pattern if you install it.
+
+// import { createTypiaAdapter } from '../adapters/typia.ts'
+
+export function typiaPattern() {
+	/*
+
+	// Define attributes manually (Typia strips types at compile time)
+	const attrs: VMAttributeDef[] = [
+		{ name: 'title', atPath: 'note/title', optional: false },
+		{ name: 'body', atPath: 'note/body', optional: false },
+		{ name: 'tags', atPath: 'note/tags', optional: true },
+	]
+
+	// Then create the adapter with a typia validator
+	// import typia from 'typia'
+	// interface Note { title: string; body: string; tags?: string }
+	// const validate = typia.createValidate<Note>()
+
+	const NoteVM = createViewModelFactory<Note>({
+		adapter: createTypiaAdapter(
+			// validate, // your typia validator
+			{} as any, // placeholder
+			'note',
+			{ attributes: attrs },
+		),
+		vmName: 'Note',
+	})
+
+	*/
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 5. Minimal adapter (no schema library)
+// ═══════════════════════════════════════════════════════════════
+
+export function minimalNoSchemaExample() {
+	// You don't need a schema library at all — use createAdapterFromAttributes
+
+	const adapter: ISchemaAdapter<Note> = {
+		getAttributeDefs: (): VMAttributeDef[] => [
+			{ name: 'title', atPath: 'note/title', optional: false },
+			{ name: 'body', atPath: 'note/body', optional: false },
+			{ name: 'tags', atPath: 'note/tags', optional: true },
+		],
+		getDefaults: () => ({ title: '', body: '' }),
+		getEntityPrefix: () => 'note',
+	}
+
+	const NoteVM = createViewModelFactory<Note>({
+		adapter,
+		vmName: 'Note',
+	})
+
+	console.log('Minimal NoteVM created:', NoteVM.vmName)
+}