@voidhash/mimic 0.0.1-alpha.1

package/tests/primitives/Literal.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Primitive from "../../src/Primitive";
+import * as ProxyEnvironment from "../../src/ProxyEnvironment";
+import * as OperationPath from "../../src/OperationPath";
+import * as Operation from "../../src/Operation";
+
+describe("LiteralPrimitive", () => {
+  describe("proxy", () => {
+    it("set() generates correct operation with string literal", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => operations.push(op));
+
+      const literalPrimitive = Primitive.Literal("active" as const);
+      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set("active");
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("literal.set");
+      expect(operations[0]!.payload).toBe("active");
+    });
+
+    it("set() generates correct operation with number literal", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => operations.push(op));
+
+      const literalPrimitive = Primitive.Literal(42 as const);
+      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set(42);
+
+      expect(operations[0]!.payload).toBe(42);
+    });
+
+    it("set() generates correct operation with boolean literal", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => operations.push(op));
+
+      const literalPrimitive = Primitive.Literal(true as const);
+      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set(true);
+
+      expect(operations[0]!.payload).toBe(true);
+    });
+
+    it("set() generates correct operation with null literal", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => operations.push(op));
+
+      const literalPrimitive = Primitive.Literal(null);
+      const proxy = literalPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set(null);
+
+      expect(operations[0]!.payload).toBe(null);
+    });
+  });
+
+  describe("applyOperation", () => {
+    it("returns the literal value from literal.set operation", () => {
+      const literalPrimitive = Primitive.Literal("foo" as const);
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "literal.set",
+        path: OperationPath.make(""),
+        payload: "foo",
+      };
+
+      const result = literalPrimitive._internal.applyOperation(undefined, operation);
+      expect(result).toBe("foo");
+    });
+
+    it("throws ValidationError for wrong literal value", () => {
+      const literalPrimitive = Primitive.Literal("foo" as const);
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "literal.set",
+        path: OperationPath.make(""),
+        payload: "bar",
+      };
+
+      expect(() => literalPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+
+    it("throws ValidationError for wrong operation kind", () => {
+      const literalPrimitive = Primitive.Literal("foo" as const);
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make(""),
+        payload: "foo",
+      };
+
+      expect(() => literalPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+  });
+
+  describe("getInitialState", () => {
+    it("returns undefined when no default is set", () => {
+      const literalPrimitive = Primitive.Literal("test" as const);
+      expect(literalPrimitive._internal.getInitialState()).toBeUndefined();
+    });
+
+    it("returns the default value when set", () => {
+      const literalPrimitive = Primitive.Literal("active" as const).default("active");
+      expect(literalPrimitive._internal.getInitialState()).toBe("active");
+    });
+  });
+
+  describe("literal accessor", () => {
+    it("returns the literal value", () => {
+      const literalPrimitive = Primitive.Literal("myLiteral" as const);
+      expect(literalPrimitive.literal).toBe("myLiteral");
+    });
+  });
+});
+
+// =============================================================================
+// Struct Primitive Tests
+// =============================================================================

package/tests/primitives/Number.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Primitive from "../../src/Primitive";
+import * as ProxyEnvironment from "../../src/ProxyEnvironment";
+import * as OperationPath from "../../src/OperationPath";
+import * as Operation from "../../src/Operation";
+
+describe("NumberPrimitive", () => {
+  describe("proxy", () => {
+    it("set() generates correct operation with path and payload", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => operations.push(op));
+
+      const numberPrimitive = Primitive.Number().required();
+      const proxy = numberPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set(42);
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("number.set");
+      expect(operations[0]!.payload).toBe(42);
+    });
+
+    it("set() works with decimal numbers", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => operations.push(op));
+
+      const numberPrimitive = Primitive.Number();
+      const proxy = numberPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set(3.14159);
+
+      expect(operations[0]!.payload).toBe(3.14159);
+    });
+
+    it("set() works with negative numbers", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => operations.push(op));
+
+      const numberPrimitive = Primitive.Number();
+      const proxy = numberPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set(-100);
+
+      expect(operations[0]!.payload).toBe(-100);
+    });
+  });
+
+  describe("applyOperation", () => {
+    it("returns the new number value from number.set operation", () => {
+      const numberPrimitive = Primitive.Number();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "number.set",
+        path: OperationPath.make(""),
+        payload: 123,
+      };
+
+      const result = numberPrimitive._internal.applyOperation(undefined, operation);
+      expect(result).toBe(123);
+    });
+
+    it("replaces existing state with new value", () => {
+      const numberPrimitive = Primitive.Number();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "number.set",
+        path: OperationPath.make(""),
+        payload: 999,
+      };
+
+      const result = numberPrimitive._internal.applyOperation(100, operation);
+      expect(result).toBe(999);
+    });
+
+    it("throws ValidationError for non-number payload", () => {
+      const numberPrimitive = Primitive.Number();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "number.set",
+        path: OperationPath.make(""),
+        payload: "42",
+      };
+
+      expect(() => numberPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+
+    it("throws ValidationError for wrong operation kind", () => {
+      const numberPrimitive = Primitive.Number();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make(""),
+        payload: 42,
+      };
+
+      expect(() => numberPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+  });
+
+  describe("getInitialState", () => {
+    it("returns undefined when no default is set", () => {
+      const numberPrimitive = Primitive.Number();
+      expect(numberPrimitive._internal.getInitialState()).toBeUndefined();
+    });
+
+    it("returns the default value when set", () => {
+      const numberPrimitive = Primitive.Number().default(0);
+      expect(numberPrimitive._internal.getInitialState()).toBe(0);
+    });
+  });
+
+  describe("schema modifiers", () => {
+    it("required() returns a new NumberPrimitive", () => {
+      const original = Primitive.Number();
+      const required = original.required();
+
+      expect(required).toBeInstanceOf(Primitive.NumberPrimitive);
+      expect(required).not.toBe(original);
+    });
+
+    it("default() returns a new NumberPrimitive with default value", () => {
+      const original = Primitive.Number();
+      const withDefault = original.default(100);
+
+      expect(withDefault).toBeInstanceOf(Primitive.NumberPrimitive);
+      expect(withDefault._internal.getInitialState()).toBe(100);
+    });
+  });
+});
+
+// =============================================================================
+// Literal Primitive Tests
+// =============================================================================

package/tests/primitives/String.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Primitive from "../../src/Primitive";
+import * as ProxyEnvironment from "../../src/ProxyEnvironment";
+import * as OperationPath from "../../src/OperationPath";
+import * as Operation from "../../src/Operation";
+
+describe("StringPrimitive", () => {
+  describe("proxy", () => {
+    it("set() generates correct operation with path and payload", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const stringPrimitive = Primitive.String().required();
+      const proxy = stringPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set("Hello World");
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.payload).toBe("Hello World");
+    });
+
+    it("set() includes the correct path in operation", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const stringPrimitive = Primitive.String();
+      const proxy = stringPrimitive._internal.createProxy(env, OperationPath.make("users/0/name"));
+
+      proxy.set("John");
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.path.toTokens()).toEqual(["users", "0", "name"]);
+    });
+  });
+
+  describe("applyOperation", () => {
+    it("returns the new string value from string.set operation", () => {
+      const stringPrimitive = Primitive.String();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make(""),
+        payload: "New Value",
+      };
+
+      const result = stringPrimitive._internal.applyOperation(undefined, operation);
+
+      expect(result).toBe("New Value");
+    });
+
+    it("replaces existing state with new value", () => {
+      const stringPrimitive = Primitive.String();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make(""),
+        payload: "Updated",
+      };
+
+      const result = stringPrimitive._internal.applyOperation("Original", operation);
+
+      expect(result).toBe("Updated");
+    });
+
+    it("throws ValidationError for non-string payload", () => {
+      const stringPrimitive = Primitive.String();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make(""),
+        payload: 123,
+      };
+
+      expect(() => stringPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+
+    it("throws ValidationError for wrong operation kind", () => {
+      const stringPrimitive = Primitive.String();
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "wrong.kind",
+        path: OperationPath.make(""),
+        payload: "value",
+      };
+
+      expect(() => stringPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+  });
+
+  describe("getInitialState", () => {
+    it("returns undefined when no default is set", () => {
+      const stringPrimitive = Primitive.String();
+      expect(stringPrimitive._internal.getInitialState()).toBeUndefined();
+    });
+
+    it("returns the default value when set", () => {
+      const stringPrimitive = Primitive.String().default("Default Text");
+      expect(stringPrimitive._internal.getInitialState()).toBe("Default Text");
+    });
+  });
+
+  describe("schema modifiers", () => {
+    it("required() returns a new StringPrimitive", () => {
+      const original = Primitive.String();
+      const required = original.required();
+
+      expect(required).toBeInstanceOf(Primitive.StringPrimitive);
+      expect(required).not.toBe(original);
+    });
+
+    it("default() returns a new StringPrimitive with default value", () => {
+      const original = Primitive.String();
+      const withDefault = original.default("test");
+
+      expect(withDefault).toBeInstanceOf(Primitive.StringPrimitive);
+      expect(withDefault._internal.getInitialState()).toBe("test");
+    });
+  });
+});
+
+// =============================================================================
+// Boolean Primitive Tests
+// =============================================================================

package/tests/primitives/Struct.test.ts

@@ -0,0 +1,311 @@
+import { describe, expect, it } from "@effect/vitest";
+import * as Primitive from "../../src/Primitive";
+import * as ProxyEnvironment from "../../src/ProxyEnvironment";
+import * as OperationPath from "../../src/OperationPath";
+import * as Operation from "../../src/Operation";
+
+describe("StructPrimitive", () => {
+  describe("proxy", () => {
+    it("nested field access returns field primitive proxy", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String().required(),
+        title: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      // Access nested field and call set
+      proxy.name.set("John Doe");
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.payload).toBe("John Doe");
+      expect(operations[0]!.path.toTokens()).toEqual(["name"]);
+    });
+
+    it("nested field paths are constructed correctly", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make("users/0"));
+
+      proxy.email.set("test@example.com");
+
+      expect(operations[0]!.path.toTokens()).toEqual(["users", "0", "email"]);
+    });
+
+    it("set() on struct generates struct.set operation", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        age: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set({ name: "Alice", age: "30" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("struct.set");
+      expect(operations[0]!.payload).toEqual({ name: "Alice", age: "30" });
+    });
+
+    it("multiple field sets generate separate operations", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        firstName: Primitive.String(),
+        lastName: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.firstName.set("John");
+      proxy.lastName.set("Doe");
+
+      expect(operations).toHaveLength(2);
+      expect(operations[0]!.payload).toBe("John");
+      expect(operations[1]!.payload).toBe("Doe");
+    });
+  });
+
+  describe("applyOperation", () => {
+    it("struct.set replaces entire struct state", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "struct.set",
+        path: OperationPath.make(""),
+        payload: { name: "Bob", email: "bob@test.com" },
+      };
+
+      const result = structPrimitive._internal.applyOperation(undefined, operation);
+
+      expect(result).toEqual({ name: "Bob", email: "bob@test.com" });
+    });
+
+    it("delegates field operations to nested primitives", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        title: Primitive.String(),
+      });
+
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make("name"),
+        payload: "Updated Name",
+      };
+
+      const currentState = { name: "Original", title: "Mr" };
+      const result = structPrimitive._internal.applyOperation(currentState, operation);
+
+      expect(result).toEqual({ name: "Updated Name", title: "Mr" });
+    });
+
+    it("creates state from undefined when applying field operation", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+      });
+
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make("name"),
+        payload: "New Name",
+      };
+
+      const result = structPrimitive._internal.applyOperation(undefined, operation);
+
+      expect(result).toEqual({ name: "New Name" });
+    });
+
+    it("throws ValidationError for unknown field", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+      });
+
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make("unknownField"),
+        payload: "value",
+      };
+
+      expect(() => structPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+
+    it("throws ValidationError for non-object payload on struct.set", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+      });
+
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "struct.set",
+        path: OperationPath.make(""),
+        payload: "not an object",
+      };
+
+      expect(() => structPrimitive._internal.applyOperation(undefined, operation)).toThrow(
+        Primitive.ValidationError
+      );
+    });
+  });
+
+  describe("getInitialState", () => {
+    it("returns undefined when no field has defaults", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      expect(structPrimitive._internal.getInitialState()).toBeUndefined();
+    });
+
+    it("returns partial state from field defaults", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String().default("Anonymous"),
+        email: Primitive.String(),
+      });
+
+      const initialState = structPrimitive._internal.getInitialState();
+
+      expect(initialState).toEqual({ name: "Anonymous" });
+    });
+
+    it("returns complete state when all fields have defaults", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String().default("Guest"),
+        role: Primitive.String().default("user"),
+      });
+
+      const initialState = structPrimitive._internal.getInitialState();
+
+      expect(initialState).toEqual({ name: "Guest", role: "user" });
+    });
+
+    it("uses struct default value over field defaults", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String().default("Field Default"),
+      }).default({ name: "Struct Default" });
+
+      const initialState = structPrimitive._internal.getInitialState();
+
+      expect(initialState).toEqual({ name: "Struct Default" });
+    });
+  });
+
+  describe("nested structs", () => {
+    it("supports nested struct primitives", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const addressPrimitive = Primitive.Struct({
+        street: Primitive.String(),
+        city: Primitive.String(),
+      });
+
+      const personPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        address: addressPrimitive,
+      });
+
+      const proxy = personPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.address.city.set("New York");
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.payload).toBe("New York");
+      expect(operations[0]!.path.toTokens()).toEqual(["address", "city"]);
+    });
+
+    it("applies operations to nested structs", () => {
+      const addressPrimitive = Primitive.Struct({
+        street: Primitive.String(),
+        city: Primitive.String(),
+      });
+
+      const personPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        address: addressPrimitive,
+      });
+
+      const operation: Operation.Operation<any, any, any> = {
+        kind: "string.set",
+        path: OperationPath.make("address/city"),
+        payload: "Los Angeles",
+      };
+
+      const currentState = {
+        name: "John",
+        address: { street: "123 Main St", city: "San Francisco" },
+      };
+
+      const result = personPrimitive._internal.applyOperation(currentState, operation);
+
+      expect(result).toEqual({
+        name: "John",
+        address: { street: "123 Main St", city: "Los Angeles" },
+      });
+    });
+  });
+
+  describe("type inference", () => {
+    it("infers correct state type from struct definition", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      // This is a compile-time check - the type should be inferred correctly
+      type ExpectedState = Primitive.InferState<typeof structPrimitive>;
+      const state: ExpectedState = { name: "test", email: "test@test.com" };
+
+      expect(state).toEqual({ name: "test", email: "test@test.com" });
+    });
+
+    it("infers correct proxy type with field access", () => {
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+      });
+
+      type ExpectedProxy = Primitive.InferProxy<typeof structPrimitive>;
+
+      // This would fail at compile time if types are wrong
+      const env = ProxyEnvironment.make(() => {});
+      const proxy: ExpectedProxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      // Verify the proxy has the expected shape
+      expect(typeof proxy.name.set).toBe("function");
+      expect(typeof proxy.set).toBe("function");
+    });
+  });
+});
+
+// =============================================================================
+// Array Primitive Tests (Ordered with ID + Fractional Index)
+// =============================================================================