@ontrails/core 1.0.0-beta.15 → 1.0.0-beta.16

package/src/__tests__/validation.test.ts

@@ -1,336 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { ValidationError } from '../errors.js';
-import {
-  validateInput,
-  validateOutput,
-  formatZodIssues,
-  zodToJsonSchema,
-} from '../validation.js';
-
-// ---------------------------------------------------------------------------
-// validateInput
-// ---------------------------------------------------------------------------
-
-describe('validateInput', () => {
-  const schema = z.object({
-    age: z.number().min(0),
-    name: z.string(),
-  });
-
-  test('returns Ok for valid data', () => {
-    const result = validateInput(schema, { age: 30, name: 'Alice' });
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ age: 30, name: 'Alice' });
-  });
-
-  test('returns Err with ValidationError for invalid data', () => {
-    const result = validateInput(schema, { name: 123 });
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error).toBeInstanceOf(ValidationError);
-    expect(err.error.category).toBe('validation');
-  });
-
-  test('includes formatted issues in error message', () => {
-    const result = validateInput(schema, {});
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error.message).toContain('name');
-  });
-
-  test('attaches ZodError as cause', () => {
-    const result = validateInput(schema, {});
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error.cause).toBeInstanceOf(z.ZodError);
-  });
-
-  test('attaches issues in context', () => {
-    const result = validateInput(schema, {});
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error.context).toBeDefined();
-    expect(Array.isArray(err.error.context?.['issues'])).toBe(true);
-  });
-
-  test('works with simple string schema', () => {
-    const str = z.string().min(1);
-    expect(validateInput(str, 'hello').isOk()).toBe(true);
-    expect(validateInput(str, '').isErr()).toBe(true);
-    expect(validateInput(str, 42).isErr()).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// validateOutput
-// ---------------------------------------------------------------------------
-
-describe('validateOutput', () => {
-  const schema = z.object({
-    id: z.string(),
-    score: z.number(),
-  });
-
-  test('returns Ok for valid data', () => {
-    const result = validateOutput(schema, { id: 'abc', score: 42 });
-    expect(result.isOk()).toBe(true);
-    expect(result.unwrap()).toEqual({ id: 'abc', score: 42 });
-  });
-
-  test('returns Err with ValidationError for invalid data', () => {
-    const result = validateOutput(schema, { id: 123 });
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error).toBeInstanceOf(ValidationError);
-    expect(err.error.category).toBe('validation');
-  });
-
-  test('error message includes "Output validation failed" prefix', () => {
-    const result = validateOutput(schema, {});
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error.message).toContain('Output validation failed');
-  });
-
-  test('attaches ZodError as cause', () => {
-    const result = validateOutput(schema, {});
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error.cause).toBeInstanceOf(z.ZodError);
-  });
-
-  test('attaches issues in context', () => {
-    const result = validateOutput(schema, {});
-    expect(result.isErr()).toBe(true);
-    const err = result as unknown as { error: ValidationError };
-    expect(err.error.context).toBeDefined();
-    expect(Array.isArray(err.error.context?.['issues'])).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// formatZodIssues
-// ---------------------------------------------------------------------------
-
-describe('formatZodIssues', () => {
-  test('formats issues with paths', () => {
-    const schema = z.object({ email: z.string().email() });
-    const parsed = schema.safeParse({ email: 'not-email' });
-    expect(parsed.success).toBe(false);
-    const failed1 = parsed as unknown as { error: z.ZodError };
-    const messages1 = formatZodIssues(failed1.error.issues);
-    expect(messages1.length).toBeGreaterThan(0);
-    expect(messages1[0]).toMatch(/^email: /);
-  });
-
-  test('formats root-level issues without path prefix', () => {
-    const schema = z.string();
-    const parsed = schema.safeParse(42);
-    expect(parsed.success).toBe(false);
-    const failed = parsed as unknown as { error: z.ZodError };
-    const messages = formatZodIssues(failed.error.issues);
-    expect(messages.length).toBeGreaterThan(0);
-    // Root issues have no "path: " prefix — message starts directly
-    // (the message itself may contain colons, but won't start with "path: ")
-    expect(messages[0]).not.toMatch(/^\w+: /);
-  });
-
-  test('formats nested paths with dot notation', () => {
-    const schema = z.object({
-      user: z.object({ name: z.string() }),
-    });
-    const parsed = schema.safeParse({ user: { name: 123 } });
-    expect(parsed.success).toBe(false);
-    const failed = parsed as unknown as { error: z.ZodError };
-    const messages = formatZodIssues(failed.error.issues);
-    expect(messages[0]).toMatch(/^user\.name: /);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// zodToJsonSchema
-// ---------------------------------------------------------------------------
-
-describe('zodToJsonSchema', () => {
-  describe('primitives', () => {
-    test('converts z.string()', () => {
-      expect(zodToJsonSchema(z.string())).toEqual({ type: 'string' });
-    });
-
-    test('converts z.number()', () => {
-      expect(zodToJsonSchema(z.number())).toEqual({ type: 'number' });
-    });
-
-    test('converts z.boolean()', () => {
-      expect(zodToJsonSchema(z.boolean())).toEqual({ type: 'boolean' });
-    });
-
-    test('converts z.literal()', () => {
-      expect(zodToJsonSchema(z.literal('hello'))).toEqual({ const: 'hello' });
-      expect(zodToJsonSchema(z.literal(42))).toEqual({ const: 42 });
-    });
-
-    test('converts z.enum()', () => {
-      expect(zodToJsonSchema(z.enum(['a', 'b', 'c']))).toEqual({
-        enum: ['a', 'b', 'c'],
-        type: 'string',
-      });
-    });
-
-    test('converts z.array()', () => {
-      expect(zodToJsonSchema(z.array(z.string()))).toEqual({
-        items: { type: 'string' },
-        type: 'array',
-      });
-    });
-  });
-
-  describe('objects', () => {
-    test('converts z.object() with required fields', () => {
-      const schema = z.object({ age: z.number(), name: z.string() });
-      const result = zodToJsonSchema(schema);
-      expect(result).toEqual({
-        properties: {
-          age: { type: 'number' },
-          name: { type: 'string' },
-        },
-        required: ['age', 'name'],
-        type: 'object',
-      });
-    });
-
-    test('converts z.object() with optional fields', () => {
-      const schema = z.object({
-        name: z.string(),
-        nickname: z.string().optional(),
-      });
-      const result = zodToJsonSchema(schema);
-      expect(result).toEqual({
-        properties: {
-          name: { type: 'string' },
-          nickname: { type: 'string' },
-        },
-        required: ['name'],
-        type: 'object',
-      });
-    });
-
-    test('converts z.object() with default fields', () => {
-      const schema = z.object({
-        name: z.string(),
-        role: z.string().default('user'),
-      });
-      const result = zodToJsonSchema(schema);
-      expect(result).toEqual({
-        properties: {
-          name: { type: 'string' },
-          role: { default: 'user', type: 'string' },
-        },
-        required: ['name'],
-        type: 'object',
-      });
-    });
-
-    test('handles nested objects', () => {
-      const schema = z.object({
-        user: z.object({ name: z.string() }),
-      });
-      expect(zodToJsonSchema(schema)).toEqual({
-        properties: {
-          user: {
-            properties: { name: { type: 'string' } },
-            required: ['name'],
-            type: 'object',
-          },
-        },
-        required: ['user'],
-        type: 'object',
-      });
-    });
-  });
-
-  describe('modifiers and combinators', () => {
-    test('converts z.union()', () => {
-      const schema = z.union([z.string(), z.number()]);
-      expect(zodToJsonSchema(schema)).toEqual({
-        anyOf: [{ type: 'string' }, { type: 'number' }],
-      });
-    });
-
-    test('preserves z.describe()', () => {
-      const schema = z.string().describe('A user name');
-      expect(zodToJsonSchema(schema)).toEqual({
-        description: 'A user name',
-        type: 'string',
-      });
-    });
-
-    test('handles z.nullable()', () => {
-      const schema = z.string().nullable();
-      expect(zodToJsonSchema(schema)).toEqual({
-        anyOf: [{ type: 'string' }, { type: 'null' }],
-      });
-    });
-
-    test('returns empty object for unknown types', () => {
-      // z.any() is not in our coverage list
-      expect(zodToJsonSchema(z.any())).toEqual({});
-    });
-  });
-
-  describe('default values', () => {
-    test('preserves static defaults as-is', () => {
-      const schema = z.string().default('hello');
-      expect(zodToJsonSchema(schema)).toEqual({
-        default: 'hello',
-        type: 'string',
-      });
-    });
-
-    test('omits dynamic defaults that produce different values', () => {
-      let counter = 0;
-      const schema = z.string().default(() => {
-        counter += 1;
-        return `id-${counter}`;
-      });
-      const result = zodToJsonSchema(schema);
-      expect(result).toEqual({ type: 'string' });
-      expect(result['default']).toBeUndefined();
-    });
-
-    test('preserves stable functional defaults that return constant values', () => {
-      const schema = z.string().default(() => 'constant');
-      const result = zodToJsonSchema(schema);
-      expect(result).toEqual({ default: 'constant', type: 'string' });
-    });
-
-    test('preserves stable functional defaults that return equivalent objects', () => {
-      const schema = z
-        .object({ key: z.string() })
-        .default(() => ({ key: 'val' }));
-      const result = zodToJsonSchema(schema);
-      expect(result['default']).toEqual({ key: 'val' });
-    });
-
-    test('preserves stable functional defaults that return equivalent arrays', () => {
-      const schema = z.array(z.string()).default(() => ['a', 'b']);
-      const result = zodToJsonSchema(schema);
-      expect(result['default']).toEqual(['a', 'b']);
-    });
-
-    test('produces identical output across repeated calls', () => {
-      let counter = 0;
-      const schema = z.string().default(() => {
-        counter += 1;
-        return `id-${counter}`;
-      });
-      const first = zodToJsonSchema(schema);
-      const second = zodToJsonSchema(schema);
-      // Key invariant: repeated calls always produce the same schema
-      expect(first).toEqual(second);
-    });
-  });
-});

package/src/__tests__/workspace.test.ts

@@ -1,183 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { resolve, join } from 'node:path';
-
-import { NotFoundError } from '../errors.js';
-import {
-  findWorkspaceRoot,
-  isInsideWorkspace,
-  deriveRelativePath,
-} from '../workspace.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const createTempDir = (): string =>
-  mkdtempSync(join(tmpdir(), 'trails-ws-test-'));
-
-const writeJson = (dir: string, filename: string, data: unknown): void => {
-  writeFileSync(join(dir, filename), JSON.stringify(data, null, 2));
-};
-
-/** Set up nested workspaces: outer > inner > packages/lib. Returns the deepest path. */
-const setupNestedWorkspaces = (outer: string): string => {
-  writeJson(outer, 'package.json', { name: 'outer', workspaces: ['inner/*'] });
-  const inner = join(outer, 'inner', 'nested');
-  mkdirSync(inner, { recursive: true });
-  writeJson(join(outer, 'inner'), 'package.json', {
-    name: 'inner',
-    workspaces: ['packages/*'],
-  });
-  const deep = join(inner, 'packages', 'lib');
-  mkdirSync(deep, { recursive: true });
-  return deep;
-};
-
-// ---------------------------------------------------------------------------
-// findWorkspaceRoot
-// ---------------------------------------------------------------------------
-
-describe('findWorkspaceRoot', () => {
-  test('finds workspace root when started inside a nested directory', async () => {
-    const root = createTempDir();
-    try {
-      writeJson(root, 'package.json', {
-        name: 'my-workspace',
-        workspaces: ['packages/*'],
-      });
-
-      const nested = join(root, 'packages', 'core', 'src');
-      mkdirSync(nested, { recursive: true });
-
-      const result = await findWorkspaceRoot(nested);
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toBe(resolve(root));
-    } finally {
-      rmSync(root, { force: true, recursive: true });
-    }
-  });
-
-  test('skips package.json without workspaces field', async () => {
-    const root = createTempDir();
-    try {
-      // Root has workspaces
-      writeJson(root, 'package.json', {
-        name: 'root',
-        workspaces: ['packages/*'],
-      });
-
-      // Nested package has no workspaces
-      const pkg = join(root, 'packages', 'core');
-      mkdirSync(pkg, { recursive: true });
-      writeJson(pkg, 'package.json', { name: '@scope/core' });
-
-      const result = await findWorkspaceRoot(pkg);
-      expect(result.isOk()).toBe(true);
-      expect(result.unwrap()).toBe(resolve(root));
-    } finally {
-      rmSync(root, { force: true, recursive: true });
-    }
-  });
-
-  test('returns the closest workspace root', async () => {
-    const outer = createTempDir();
-    try {
-      const deep = setupNestedWorkspaces(outer);
-      const result = await findWorkspaceRoot(deep);
-      expect(result.isOk()).toBe(true);
-      // Should find inner workspace first (closest ancestor)
-      expect(result.unwrap()).toBe(resolve(join(outer, 'inner')));
-    } finally {
-      rmSync(outer, { force: true, recursive: true });
-    }
-  });
-
-  test('returns NotFoundError when no workspace root exists', async () => {
-    const dir = createTempDir();
-    try {
-      // No package.json at all
-      const result = await findWorkspaceRoot(dir);
-      // This will either find one above in the actual filesystem or fail.
-      // We walk up to /, so it depends on the host. Use a deep isolated path.
-      // Since tmpdir might be under a workspace, let's just check the type
-      // is correct if it does fail. When the host has a workspace root above
-      // tmpdir, the result will be Ok — both outcomes are acceptable.
-      const isAcceptable =
-        // oxlint-disable-next-line no-conditional-in-test -- host-dependent: tmpdir may sit under a real workspace
-        result.isOk() ||
-        (result as unknown as { error: Error }).error instanceof NotFoundError;
-      expect(isAcceptable).toBe(true);
-    } finally {
-      rmSync(dir, { force: true, recursive: true });
-    }
-  });
-
-  test('handles malformed package.json gracefully', async () => {
-    const root = createTempDir();
-    try {
-      // Write invalid JSON
-      writeFileSync(join(root, 'package.json'), 'not json {{{');
-
-      const result = await findWorkspaceRoot(root);
-      // Should not throw — just skip and keep walking.
-      // On some hosts tmpdir sits under a real workspace, so Ok is valid too.
-      const isAcceptable =
-        // oxlint-disable-next-line no-conditional-in-test -- host-dependent: tmpdir may sit under a real workspace
-        result.isOk() ||
-        (result as unknown as { error: Error }).error instanceof NotFoundError;
-      expect(isAcceptable).toBe(true);
-    } finally {
-      rmSync(root, { force: true, recursive: true });
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// isInsideWorkspace
-// ---------------------------------------------------------------------------
-
-describe('isInsideWorkspace', () => {
-  test('returns true for a file inside the workspace', () => {
-    expect(
-      isInsideWorkspace('/project/packages/core/src/index.ts', '/project')
-    ).toBe(true);
-  });
-
-  test('returns false for a file outside the workspace', () => {
-    expect(isInsideWorkspace('/other/file.ts', '/project')).toBe(false);
-  });
-
-  test('returns false for the workspace root itself', () => {
-    // The root directory itself is not \"inside\" the workspace
-    expect(isInsideWorkspace('/project', '/project')).toBe(false);
-  });
-
-  test('handles relative-looking paths by resolving them', () => {
-    expect(
-      isInsideWorkspace('/project/packages/../packages/core', '/project')
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// deriveRelativePath
-// ---------------------------------------------------------------------------
-
-describe('deriveRelativePath', () => {
-  test('returns relative path from workspace root', () => {
-    expect(
-      deriveRelativePath('/project/packages/core/src/index.ts', '/project')
-    ).toBe('packages/core/src/index.ts');
-  });
-
-  test('returns .. segments for paths outside workspace', () => {
-    const rel = deriveRelativePath('/other/file.ts', '/project');
-    expect(rel.startsWith('..')).toBe(true);
-  });
-
-  test('returns empty string for the root itself', () => {
-    expect(deriveRelativePath('/project', '/project')).toBe('');
-  });
-});

package/src/__tests__/zod-wrappers.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-
-import {
-  stripDefaultsFromShape,
-  stripDefaultWrappers,
-} from '../internal/zod-wrappers.js';
-
-describe('stripDefaultWrappers', () => {
-  test('drops plain default wrappers', () => {
-    const withDefault = z.string().default('x');
-    const stripped = stripDefaultWrappers(withDefault);
-
-    expect(stripped.def.type).toBe('string');
-    // Feeding an undefined through the stripped schema no longer
-    // materializes the default.
-    expect(stripped.safeParse().success).toBe(false);
-    expect(stripped.safeParse('value').success).toBe(true);
-  });
-
-  test('drops optional + default layers together', () => {
-    const schema = z.string().optional().default('x');
-    const stripped = stripDefaultWrappers(schema);
-
-    // Every wrapper around the underlying string is gone — optional is
-    // dropped on purpose because downstream `.partial()` calls re-add it.
-    expect(stripped.def.type).toBe('string');
-    expect(stripped.safeParse().success).toBe(false);
-    expect(stripped.safeParse('value').success).toBe(true);
-  });
-
-  test('preserves nullable constraints through the strip', () => {
-    const schema = z.string().nullable().default('x');
-    const stripped = stripDefaultWrappers(schema);
-
-    // Default is gone; null is still a legal input.
-    expect(stripped.def.type).toBe('nullable');
-    expect(stripped.safeParse(null).success).toBe(true);
-    expect(stripped.safeParse('value').success).toBe(true);
-  });
-
-  test('is load-bearing for .partial() on both call sites', () => {
-    const shape = {
-      author: z.string().optional().default('anon'),
-      title: z.string().default('untitled'),
-    };
-    const schema = z.object(shape);
-
-    // Both the store `deriveUpdateSchema` helper and the core derive-trail
-    // `toPartialSchema` helper compose the same pattern: extend the schema
-    // with the stripped shape, then call `.partial()`. Both call sites
-    // must produce a schema that accepts an empty object without
-    // re-materializing defaults.
-    const stripped = stripDefaultsFromShape(schema);
-    const partial = schema.extend(stripped).partial();
-
-    const parsed = partial.parse({});
-    expect(parsed).toEqual({});
-    expect('author' in parsed).toBe(false);
-    expect('title' in parsed).toBe(false);
-  });
-});