@smoothbricks/lmao 0.1.0

package/src/lib/__tests__/op-context-binding.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Op._opContextBinding Tests
+ *
+ * Tests that the full context wiring pipeline works:
+ * - defineOpContext().defineOp() produces Ops with _opContextBinding set
+ * - The binding's logBinding.logSchema.fields contains the schema fields
+ * - .prefix() on an OpGroup preserves _opContextBinding on resulting Ops
+ * - .mapColumns() preserves _opContextBinding
+ * - Two Ops from the same defineOpContext share the same binding reference (identity dedup)
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { defineOpContext } from '../defineOpContext.js';
+import { Op } from '../op.js';
+import type { OpContextBinding } from '../opContext/types.js';
+import { S } from '../schema/builder.js';
+import { defineLogSchema } from '../schema/defineLogSchema.js';
+
+const testSchema = defineLogSchema({
+  userId: S.category(),
+  endpoint: S.text(),
+});
+
+function requireBinding(binding: OpContextBinding | undefined, label: string): OpContextBinding {
+  if (!binding) {
+    throw new Error(`Expected ${label} to have an _opContextBinding`);
+  }
+  return binding;
+}
+
+describe('Op._opContextBinding', () => {
+  it('defineOp produces an Op with _opContextBinding set', () => {
+    const ctx = defineOpContext({ logSchema: testSchema });
+    const op = ctx.defineOp('test-op', (ctx) => ctx.ok('done'));
+
+    expect(op).toBeInstanceOf(Op);
+    expect(op._opContextBinding).toBeDefined();
+  });
+
+  it('binding logBinding.logSchema.fields contains the schema fields', () => {
+    const ctx = defineOpContext({ logSchema: testSchema });
+    const op = ctx.defineOp('test-op', (ctx) => ctx.ok('done'));
+
+    const binding = requireBinding(op._opContextBinding, 'op');
+    const fields = binding.logBinding.logSchema.fields;
+
+    // WHY: user-defined fields should be present in the schema
+    expect(fields).toHaveProperty('userId');
+    expect(fields).toHaveProperty('endpoint');
+  });
+
+  it('.prefix() on an OpGroup preserves _opContextBinding on resulting Ops', () => {
+    const ctx = defineOpContext({ logSchema: testSchema });
+    const ops = ctx.defineOps({
+      fetch: (ctx) => ctx.ok('fetched'),
+      save: (ctx) => ctx.ok('saved'),
+    });
+
+    const prefixed = ops.prefix('http');
+
+    const fetchOp = prefixed.fetch;
+    const saveOp = prefixed.save;
+
+    expect(fetchOp._opContextBinding).toBeDefined();
+    expect(saveOp._opContextBinding).toBeDefined();
+
+    // Binding should still reference the original schema fields
+    expect(requireBinding(fetchOp._opContextBinding, 'prefixed.fetch').logBinding.logSchema.fields).toHaveProperty(
+      'userId',
+    );
+  });
+
+  it('.mapColumns() preserves _opContextBinding', () => {
+    const ctx = defineOpContext({ logSchema: testSchema });
+    const ops = ctx.defineOps({
+      fetch: (ctx) => ctx.ok('fetched'),
+    });
+
+    const mapped = ops.mapColumns({ userId: 'mapped_user' });
+
+    const fetchOp = mapped.fetch;
+    expect(fetchOp._opContextBinding).toBeDefined();
+    expect(requireBinding(fetchOp._opContextBinding, 'mapped.fetch').logBinding.logSchema.fields).toHaveProperty(
+      'userId',
+    );
+  });
+
+  it('two Ops from the same defineOpContext share the same binding reference', () => {
+    const ctx = defineOpContext({ logSchema: testSchema });
+    const opA = ctx.defineOp('op-a', (ctx) => ctx.ok('a'));
+    const opB = ctx.defineOp('op-b', (ctx) => ctx.ok('b'));
+
+    // WHY: identity dedup — same defineOpContext produces one binding object
+    expect(opA._opContextBinding).toBe(opB._opContextBinding);
+  });
+
+  it('two Ops from different defineOpContext have different bindings', () => {
+    const ctxA = defineOpContext({ logSchema: testSchema });
+    const ctxB = defineOpContext({ logSchema: testSchema });
+
+    const opA = ctxA.defineOp('op-a', (ctx) => ctx.ok('a'));
+    const opB = ctxB.defineOp('op-b', (ctx) => ctx.ok('b'));
+
+    // WHY: different factories produce different binding objects
+    expect(opA._opContextBinding).not.toBe(opB._opContextBinding);
+  });
+
+  it('Ops from defineOps share the same binding as defineOp from same context', () => {
+    const ctx = defineOpContext({ logSchema: testSchema });
+    const singleOp = ctx.defineOp('single', (ctx) => ctx.ok('single'));
+    const group = ctx.defineOps({
+      grouped: (ctx) => ctx.ok('grouped'),
+    });
+
+    const groupedOp = group.grouped;
+
+    // WHY: all Ops from one defineOpContext share the same binding reference
+    expect(singleOp._opContextBinding).toBe(groupedOp._opContextBinding);
+  });
+
+  it('prefixed Ops from different groups share binding when from same context', () => {
+    const ctx = defineOpContext({ logSchema: testSchema });
+    const group = ctx.defineOps({
+      fetch: (ctx) => ctx.ok('fetched'),
+      save: (ctx) => ctx.ok('saved'),
+    });
+
+    const prefixed = group.prefix('http');
+    const fetchOp = prefixed.fetch;
+    const saveOp = prefixed.save;
+
+    // WHY: prefix creates new Op instances but preserves the binding reference
+    expect(fetchOp._opContextBinding).toBe(saveOp._opContextBinding);
+  });
+});

package/src/lib/__tests__/op-metadata.test.ts

@@ -0,0 +1,198 @@
+/**
+ * Op Metadata Tests
+ *
+ * Tests that OpMetadata is correctly set when using defineOp and defineOps.
+ * Verifies that:
+ * - Op name is correctly captured from defineOp('name', fn)
+ * - Metadata flows through to the Op instance
+ * - Stack extraction provides file/line info when transformer not installed
+ * - Transformer-injected metadata takes precedence
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { defineOpContext } from '../defineOpContext.js';
+import { Op } from '../op.js';
+import { createOpMetadata } from '../opContext/defineOp.js';
+import { S } from '../schema/builder.js';
+import { defineLogSchema } from '../schema/defineLogSchema.js';
+import { TestTracer } from '../tracers/TestTracer.js';
+import { createTestTracerOptions } from './test-helpers.js';
+
+// Test schema
+const testSchema = defineLogSchema({
+  userId: S.category(),
+});
+
+describe('Op Metadata', () => {
+  describe('defineOp name parameter', () => {
+    it('should use the name parameter as Op metadata name', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      const myOp = defineOp('my-operation', (ctx) => ctx.ok('done'));
+
+      // Op should have the name from defineOp
+      expect(myOp.metadata.name).toBe('my-operation');
+    });
+
+    it('should use different names for different ops', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      const fetchOp = defineOp('fetch-user', (ctx) => ctx.ok('user'));
+      const saveOp = defineOp('save-user', (ctx) => ctx.ok('saved'));
+
+      expect(fetchOp.metadata.name).toBe('fetch-user');
+      expect(saveOp.metadata.name).toBe('save-user');
+    });
+
+    it('should have some metadata even without transformer', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      const myOp = defineOp('test-op', (ctx) => ctx.ok('done'));
+
+      // Metadata should exist (either from stack extraction or defaults)
+      expect(myOp.metadata.package_file).toBeDefined();
+      expect(typeof myOp.metadata.line).toBe('number');
+      // Most importantly, the name should be correct
+      expect(myOp.metadata.name).toBe('test-op');
+    });
+  });
+
+  describe('defineOps with inline functions', () => {
+    it('should use the key name as Op metadata name', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOps } = ctx;
+
+      const ops = defineOps({
+        fetchUser: (ctx) => ctx.ok('user'),
+        saveUser: (ctx) => ctx.ok('saved'),
+      });
+
+      expect(ops.fetchUser.metadata.name).toBe('fetchUser');
+      expect(ops.saveUser.metadata.name).toBe('saveUser');
+    });
+
+    it('should preserve name when using pre-defined Op', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp, defineOps } = ctx;
+
+      // Pre-define an op with explicit name
+      const customOp = defineOp('custom-name', (ctx) => ctx.ok('done'));
+
+      const ops = defineOps({
+        differentKey: customOp,
+      });
+
+      // Should keep the original Op name, not the key name
+      expect(ops.differentKey.metadata.name).toBe('custom-name');
+    });
+  });
+
+  describe('transformer-injected metadata', () => {
+    it('should use explicit metadata when provided', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      const injectedMetadata = createOpMetadata('transformer-name', '@my/package', 'src/ops.ts', 'abc123', 42);
+
+      const myOp = defineOp('runtime-name', (ctx) => ctx.ok('done'), injectedMetadata);
+
+      // Transformer-injected name should take precedence
+      expect(myOp.metadata.name).toBe('transformer-name');
+      expect(myOp.metadata.package_name).toBe('@my/package');
+      expect(myOp.metadata.package_file).toBe('src/ops.ts');
+      expect(myOp.metadata.git_sha).toBe('abc123');
+      expect(myOp.metadata.line).toBe(42);
+    });
+
+    it('should use runtime name if transformer metadata has no name', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      // Partial metadata without name - simulating transformer that doesn't inject name
+      const partialMetadata: Partial<ReturnType<typeof createOpMetadata>> = {
+        package_name: '@my/package',
+        package_file: 'src/ops.ts',
+        git_sha: 'abc123',
+        line: 42,
+      };
+
+      const myOp = defineOp('runtime-name', (ctx) => ctx.ok('done'), partialMetadata);
+
+      // Runtime name should be used since metadata.name wasn't provided
+      expect(myOp.metadata.name).toBe('runtime-name');
+      expect(myOp.metadata.package_name).toBe('@my/package');
+    });
+  });
+
+  describe('metadata flows to SpanBuffer', () => {
+    it('should have metadata accessible on buffer._opMetadata during trace', async () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      let capturedMetadata: ReturnType<typeof createOpMetadata> | undefined;
+      const myOp = defineOp('traced-op', (ctx) => {
+        capturedMetadata = ctx.buffer._opMetadata;
+        return ctx.ok('done');
+      });
+
+      const tracer = new TestTracer(ctx, createTestTracerOptions());
+      await tracer.trace('test-trace', myOp);
+
+      expect(capturedMetadata).toBeDefined();
+      expect(capturedMetadata?.name).toBe('traced-op');
+    });
+
+    it('should distinguish callsite vs op metadata', async () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      let innerCallsiteMetadata: ReturnType<typeof createOpMetadata> | undefined;
+      let innerOpMetadata: ReturnType<typeof createOpMetadata> | undefined;
+
+      const innerOp = defineOp('inner-op', (ctx) => {
+        innerCallsiteMetadata = ctx.buffer._callsiteMetadata;
+        innerOpMetadata = ctx.buffer._opMetadata;
+        return ctx.ok('inner-done');
+      });
+
+      const outerOp = defineOp('outer-op', async (ctx) => {
+        await ctx.span('call-inner', innerOp);
+        return ctx.ok('outer-done');
+      });
+
+      const tracer = new TestTracer(ctx, createTestTracerOptions());
+      await tracer.trace('test-trace', outerOp);
+
+      // Inner op should have:
+      // - _callsiteMetadata from outer-op (where span() was called)
+      // - _opMetadata from inner-op (the op being executed)
+      expect(innerOpMetadata?.name).toBe('inner-op');
+      expect(innerCallsiteMetadata?.name).toBe('outer-op');
+    });
+  });
+
+  describe('Op instance type', () => {
+    it('should create Op instances', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      const myOp = defineOp('test-op', (ctx) => ctx.ok('done'));
+
+      expect(myOp).toBeInstanceOf(Op);
+    });
+
+    it('should have required Op properties', () => {
+      const ctx = defineOpContext({ logSchema: testSchema });
+      const { defineOp } = ctx;
+
+      const myOp = defineOp('test-op', (ctx) => ctx.ok('done'));
+
+      expect(myOp.metadata).toBeDefined();
+      expect(myOp.fn).toBeInstanceOf(Function);
+      expect(myOp.SpanBufferClass).toBeDefined();
+    });
+  });
+});

package/src/lib/__tests__/op-type-safety.test.ts

@@ -0,0 +1,71 @@
+/**
+ * Type safety test - verify Ops with incompatible schemas cause compile errors
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { defineOpContext } from '../defineOpContext.js';
+import { S } from '../schema/builder.js';
+import { defineLogSchema } from '../schema/defineLogSchema.js';
+import { TestTracer } from '../tracers/TestTracer.js';
+import { createTestTracerOptions } from './test-helpers.js';
+
+// Two different schemas
+const schemaA = defineLogSchema({
+  userId: S.category(),
+});
+
+const schemaB = defineLogSchema({
+  orderId: S.category(),
+});
+
+// Two different op contexts
+const opContextA = defineOpContext({
+  logSchema: schemaA,
+});
+const { defineOp: defineOpA } = opContextA;
+
+const opContextB = defineOpContext({
+  logSchema: schemaB,
+});
+const { defineOp: defineOpB } = opContextB;
+
+// Ops from each context
+const opA = defineOpA('op-a', (ctx) => {
+  ctx.tag.userId('user-123'); // Should work - userId is in schemaA
+  return ctx.ok({ a: 1 });
+});
+
+const opB = defineOpB('op-b', (ctx) => {
+  ctx.tag.orderId('order-456'); // Should work - orderId is in schemaB
+  return ctx.ok({ b: 2 });
+});
+
+describe('Op type safety', () => {
+  it('should allow Op with matching schema', async () => {
+    // New API: pass opContext directly, no explicit type parameter needed
+    const { trace } = new TestTracer(opContextA, { ...createTestTracerOptions() });
+
+    // This SHOULD work - opA was created with opContextA's schema
+    await trace('test-a', opA);
+  });
+
+  it('should ERROR when passing Op with incompatible schema', async () => {
+    // New API: pass opContext directly
+    const { trace } = new TestTracer(opContextA, { ...createTestTracerOptions() });
+
+    // This SHOULD cause a type error - opB has different schema than tracer
+    // The @ts-expect-error verifies the type system catches this at compile time
+    // At runtime, calling an op with incompatible schema will throw because
+    // the tag methods don't exist on the buffer
+    let threw = false;
+    try {
+      // @ts-expect-error - opB has schemaB but tracer expects schemaA
+      await trace('test-b', opB);
+    } catch (e) {
+      threw = true;
+      // Expected: ctx.tag.orderId is not a function because schemaA doesn't have orderId
+      expect(e).toBeInstanceOf(TypeError);
+    }
+    expect(threw).toBe(true);
+  });
+});

package/src/lib/__tests__/package-exports.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'bun:test';
+import { isRecord } from '@smoothbricks/validation';
+
+type ExportConditions = {
+  development?: string;
+  types?: string;
+  import?: string;
+  default?: string;
+};
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!isRecord(value)) {
+    throw new Error(`Expected ${label} to be an object`);
+  }
+  return value;
+}
+
+function requireStringProperty(entry: Record<string, unknown>, key: keyof ExportConditions): string {
+  const value = entry[key];
+  if (typeof value !== 'string') {
+    throw new Error(`Expected export condition '${key}' to be a string`);
+  }
+  return value;
+}
+
+function expectCoreConditions(entry: unknown): asserts entry is ExportConditions {
+  const record = requireRecord(entry, 'export conditions');
+  expect(requireStringProperty(record, 'development')).toBeString();
+  expect(requireStringProperty(record, 'types')).toBeString();
+  expect(requireStringProperty(record, 'import')).toBeString();
+  expect(requireStringProperty(record, 'default')).toBeString();
+}
+
+async function readPackageExports(packageUrl: URL): Promise<Record<string, unknown>> {
+  const pkg = await Bun.file(packageUrl).json();
+  const pkgRecord = requireRecord(pkg, 'package.json');
+  return requireRecord(pkgRecord.exports, 'package.json exports');
+}
+
+describe('package export conditions', () => {
+  it('lmao package exposes root + platform entry points with expected conditions', async () => {
+    const exports = await readPackageExports(new URL('../../../package.json', import.meta.url));
+
+    expectCoreConditions(exports['.']);
+    expectCoreConditions(exports['./node']);
+    expectCoreConditions(exports['./es']);
+
+    expect(exports['./package.json']).toBe('./package.json');
+  });
+
+  it('arrow-builder package root export has expected conditions', async () => {
+    const exports = await readPackageExports(new URL('../../../../arrow-builder/package.json', import.meta.url));
+
+    expectCoreConditions(exports['.']);
+    expect(exports['./package.json']).toBe('./package.json');
+  });
+});