laymos 0.0.1 → 0.0.2

package/dist/story/story.js

@@ -0,0 +1,56 @@
+import { Context, Effect } from 'effect';
+import { makeTraceRecorder } from '@pkishorez/effect-tracer/recorder';
+export class StoryContext extends Context.Service()('StoryContext') {
+}
+export const Story = {
+    make(story) {
+        return story;
+    },
+    question(question, options) {
+        return { question, answer: options.answer, proof: options.proof };
+    },
+    group(title, children) {
+        return { title, children };
+    },
+    trace(effect) {
+        return Effect.gen(function* () {
+            const context = yield* StoryContext;
+            const recorder = makeTraceRecorder();
+            return yield* recorder
+                .instrument(effect)
+                .pipe(Effect.onExit(() => context.beginSection({ kind: 'trace', trace: recorder.snapshot() })));
+        });
+    },
+    flow(effect) {
+        return Effect.gen(function* () {
+            const context = yield* StoryContext;
+            const recorder = makeTraceRecorder();
+            return yield* recorder
+                .instrument(effect)
+                .pipe(Effect.onExit(() => Effect.forEach(recorder.snapshotFlows(), (flow) => context.beginSection({ kind: 'flow', flow }))));
+        });
+    },
+    assert(description, passed) {
+        return Effect.flatMap(StoryContext, (context) => context.assert(description, passed));
+    },
+};
+export function isStory(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const story = value;
+    return (typeof story.title === 'string' &&
+        typeof story.sourceUrl === 'string' &&
+        Array.isArray(story.questions) &&
+        story.questions.every((question) => typeof question.question === 'string' &&
+            typeof question.answer === 'string' &&
+            Effect.isEffect(question.proof)));
+}
+export function isStoryGroup(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const group = value;
+    if (typeof group.title !== 'string' || !Array.isArray(group.children)) {
+        return false;
+    }
+    return group.children.every((child) => isStory(child) || isStoryGroup(child));
+}

package/dist/tests/authoring/index.d.ts

@@ -0,0 +1,72 @@
+import { Effect } from 'effect';
+import { describe as vitestDescribe, test as vitestTest, type ExpectStatic, type TestArtifactBase, type TestContext, type TestOptions, type SuiteOptions } from 'vitest';
+import type { LaymosTestEvidence, TestTraceSpan } from '../../report/tests.js';
+interface LaymosMetadata {
+    readonly description: string;
+    readonly documentation?: string;
+}
+interface SpanSelector {
+    readonly name?: string | RegExp;
+    readonly status?: TestTraceSpan['status'];
+    readonly attributes?: Readonly<Record<string, unknown>>;
+}
+interface TraceCapture {
+    <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+    getSpans(selector?: SpanSelector): readonly TestTraceSpan[];
+    getSpanCount(selector?: SpanSelector): number;
+}
+interface LaymosContext extends TestContext {
+    readonly expect: ExpectStatic;
+    readonly trace: TraceCapture;
+}
+type LaymosHandler = (context: LaymosContext) => LaymosHandlerResult;
+type LaymosHandlerResult = void | Promise<void> | Effect.Effect<void, unknown, never>;
+type LaymosTestOptions = Omit<TestOptions, 'fails'> & LaymosMetadata;
+type LaymosDescribeOptions = Omit<SuiteOptions, 'fails'> & LaymosMetadata;
+interface LaymosEachTest {
+    <Row extends readonly unknown[]>(cases: ReadonlyArray<Row>): (name: string, options: LaymosTestOptions, handler: (...argumentsList: [...Row, LaymosContext]) => LaymosHandlerResult) => unknown;
+    <Row>(cases: ReadonlyArray<Row>): (name: string, options: LaymosTestOptions, handler: (row: Row, context: LaymosContext) => LaymosHandlerResult) => unknown;
+    (strings: TemplateStringsArray, ...values: readonly unknown[]): (name: string, options: LaymosTestOptions, handler: (row: Readonly<Record<string, unknown>>, context: LaymosContext) => LaymosHandlerResult) => unknown;
+}
+interface LaymosTestApi {
+    (name: string, options: LaymosTestOptions, handler: LaymosHandler): unknown;
+    only: LaymosTestApi;
+    skip: LaymosTestApi;
+    todo(name: string, options: LaymosTestOptions): unknown;
+    each: LaymosEachTest;
+    extend(...argumentsList: Parameters<typeof vitestTest.extend>): LaymosTestApi;
+    skipIf(...argumentsList: Parameters<typeof vitestTest.skipIf>): LaymosTestApi;
+    runIf(...argumentsList: Parameters<typeof vitestTest.runIf>): LaymosTestApi;
+}
+interface LaymosEachDescribe {
+    <Row extends readonly unknown[]>(cases: ReadonlyArray<Row>): (name: string, options: LaymosDescribeOptions, factory: (...argumentsList: Row) => void | Promise<void>) => unknown;
+    <Row>(cases: ReadonlyArray<Row>): (name: string, options: LaymosDescribeOptions, factory: (row: Row) => void | Promise<void>) => unknown;
+    (strings: TemplateStringsArray, ...values: readonly unknown[]): (name: string, options: LaymosDescribeOptions, factory: (row: Readonly<Record<string, unknown>>) => void | Promise<void>) => unknown;
+}
+interface LaymosDescribeApi {
+    (name: string, options: LaymosDescribeOptions, factory: () => void | Promise<void>): unknown;
+    only: LaymosDescribeApi;
+    skip: LaymosDescribeApi;
+    todo(name: string, options: LaymosDescribeOptions): unknown;
+    each: LaymosEachDescribe;
+    skipIf(...argumentsList: Parameters<typeof vitestDescribe.skipIf>): LaymosDescribeApi;
+    runIf(...argumentsList: Parameters<typeof vitestDescribe.runIf>): LaymosDescribeApi;
+}
+interface LaymosTestArtifact extends TestArtifactBase {
+    readonly type: 'laymos:test-evidence';
+    readonly evidence: LaymosTestEvidence;
+}
+declare const laymosTestArtifactKey: unique symbol;
+declare module 'vitest' {
+    interface TaskMeta {
+        readonly laymosTest?: LaymosMetadata;
+        readonly laymosSuite?: LaymosMetadata;
+    }
+    interface TestArtifactRegistry {
+        [laymosTestArtifactKey]: LaymosTestArtifact;
+    }
+}
+export declare const laymosTest: LaymosTestApi;
+export declare const laymosDescribe: LaymosDescribeApi;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tests/authoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tests/authoring/index.ts"],"names":[],"mappings":"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"}

package/dist/tests/authoring/index.js

@@ -0,0 +1,312 @@
+import { Effect } from 'effect';
+import { makeTraceRecorder } from '@pkishorez/effect-tracer/recorder';
+import { stringify } from '@vitest/utils/display';
+import { describe as vitestDescribe, recordArtifact, test as vitestTest, } from 'vitest';
+const laymosTestArtifactKey = Symbol('laymos:test-evidence');
+export const laymosTest = wrapTestApi(vitestTest);
+export const laymosDescribe = wrapDescribeApi(vitestDescribe);
+function wrapTestApi(api, spreadEachArguments = false) {
+    return new Proxy(api, {
+        apply(target, thisArgument, argumentsList) {
+            const [name, options, handler] = argumentsList;
+            const metadata = validateMetadata(name, options, 'Laymos Test');
+            if (options.fails === true) {
+                throw new TypeError('Laymos Tests do not support the "fails" option');
+            }
+            const testOptions = withMeta(options, 'laymosTest', metadata);
+            if (typeof handler !== 'function') {
+                return Reflect.apply(target, thisArgument, [name, testOptions]);
+            }
+            return Reflect.apply(target, thisArgument, [
+                name,
+                testOptions,
+                async (...callbackArguments) => {
+                    const context = callbackArguments.at(-1);
+                    const callbackValues = callbackArguments.slice(0, -1);
+                    const handlerArguments = spreadEachArguments &&
+                        callbackValues.length === 1 &&
+                        Array.isArray(callbackValues[0])
+                        ? callbackValues[0]
+                        : callbackValues;
+                    const assertions = [];
+                    const assertionErrors = [];
+                    const names = new Set();
+                    const trace = makeTraceCapture();
+                    const scopedExpect = makeExpect(context.expect, assertions, assertionErrors, names);
+                    let executionError;
+                    try {
+                        const result = Reflect.apply(handler, undefined, [
+                            ...handlerArguments,
+                            { ...context, expect: scopedExpect, trace },
+                        ]);
+                        if (Effect.isEffect(result)) {
+                            await Effect.runPromise(result, { signal: context.signal });
+                        }
+                        else {
+                            await result;
+                        }
+                        if (assertions.length === 0) {
+                            throw namedError('MissingTestAssertion', 'A completed Laymos Test must record at least one named assertion');
+                        }
+                    }
+                    catch (error) {
+                        executionError = error;
+                    }
+                    finally {
+                        await recordArtifact(context.task, {
+                            type: 'laymos:test-evidence',
+                            evidence: {
+                                ...metadata,
+                                assertions,
+                                ...(trace.completedTrace === undefined
+                                    ? {}
+                                    : { trace: trace.completedTrace }),
+                            },
+                        });
+                    }
+                    if (executionError !== undefined)
+                        throw executionError;
+                    if (assertionErrors.length > 0) {
+                        const failure = new AggregateError(assertionErrors, `${assertionErrors.length} named assertion(s) failed`);
+                        failure.name = 'LaymosAssertionFailures';
+                        throw failure;
+                    }
+                },
+            ]);
+        },
+        get(target, property) {
+            const value = Reflect.get(target, property, target);
+            if (typeof value !== 'function')
+                return value;
+            if (property === 'each') {
+                const forEach = Reflect.get(target, 'for', target);
+                return (...argumentsList) => wrapTestApi(Reflect.apply(forEach, target, argumentsList), true);
+            }
+            if (property === 'extend' ||
+                property === 'skipIf' ||
+                property === 'runIf') {
+                return (...argumentsList) => wrapTestApi(Reflect.apply(value, target, argumentsList));
+            }
+            return wrapTestApi(value);
+        },
+    });
+}
+function wrapDescribeApi(api) {
+    return new Proxy(api, {
+        apply(target, thisArgument, argumentsList) {
+            const [name, options, factory] = argumentsList;
+            const metadata = validateMetadata(name, options, 'Laymos Suite');
+            if (options.fails === true) {
+                throw new TypeError('Laymos Suites do not support the "fails" option');
+            }
+            return Reflect.apply(target, thisArgument, [
+                name,
+                withMeta(options, 'laymosSuite', metadata),
+                factory,
+            ]);
+        },
+        get(target, property) {
+            const value = Reflect.get(target, property, target);
+            if (typeof value !== 'function')
+                return value;
+            if (property === 'each' ||
+                property === 'skipIf' ||
+                property === 'runIf') {
+                return (...argumentsList) => wrapDescribeApi(Reflect.apply(value, target, argumentsList));
+            }
+            return wrapDescribeApi(value);
+        },
+    });
+}
+function validateMetadata(name, options, subject) {
+    requireText(name, `${subject} name`);
+    if (!isRecord(options)) {
+        throw new TypeError(`${subject} options are required`);
+    }
+    requireText(options.description, `${subject} description`);
+    if (options.documentation !== undefined) {
+        requireText(options.documentation, `${subject} documentation`);
+    }
+    return {
+        description: options.description,
+        ...(options.documentation === undefined
+            ? {}
+            : { documentation: options.documentation }),
+    };
+}
+function withMeta(options, key, metadata) {
+    const { description: _, documentation: __, ...testOptions } = options;
+    return {
+        ...testOptions,
+        meta: {
+            ...(isRecord(options.meta) ? options.meta : {}),
+            [key]: metadata,
+        },
+    };
+}
+function makeExpect(expect, assertions, errors, names) {
+    return new Proxy(expect, {
+        apply(target, thisArgument, [actual, message]) {
+            requireText(message, 'Test Assertion name');
+            const name = message.trim();
+            if (names.has(name)) {
+                throw namedError('DuplicateTestAssertionName', `Test Assertion names must be unique: "${name}"`);
+            }
+            names.add(name);
+            const assertion = Reflect.apply(target, thisArgument, [actual, message]);
+            return wrapAssertion(assertion, {
+                actual,
+                name,
+                assertions,
+                errors,
+                path: [],
+            });
+        },
+    });
+}
+function wrapAssertion(assertion, state) {
+    return new Proxy(assertion, {
+        get(target, property) {
+            const value = Reflect.get(target, property, target);
+            const nextPath = [...state.path, String(property)];
+            if (typeof value !== 'function') {
+                return isRecord(value)
+                    ? wrapAssertion(value, { ...state, path: nextPath })
+                    : value;
+            }
+            return (...expectedArguments) => {
+                try {
+                    const result = Reflect.apply(value, target, expectedArguments);
+                    if (isPromiseLike(result)) {
+                        return result.then((resolved) => {
+                            recordAssertion(state, nextPath, expectedArguments, 'passed');
+                            return resolved;
+                        }, (error) => {
+                            recordAssertion(state, nextPath, expectedArguments, 'failed', error);
+                        });
+                    }
+                    recordAssertion(state, nextPath, expectedArguments, 'passed');
+                    return result;
+                }
+                catch (error) {
+                    recordAssertion(state, nextPath, expectedArguments, 'failed', error);
+                    return assertion;
+                }
+            };
+        },
+    });
+}
+function recordAssertion(state, path, expectedArguments, status, failure) {
+    const error = failure instanceof Error ? failure : new Error(String(failure));
+    state.assertions.push({
+        name: state.name,
+        matcher: path.join('.'),
+        status,
+        actual: testValue(state.actual),
+        ...(expectedArguments.length === 0
+            ? {}
+            : {
+                expected: testValue(expectedArguments.length === 1
+                    ? expectedArguments[0]
+                    : expectedArguments),
+            }),
+        ...(status === 'failed' ? { error: errorReport(error) } : {}),
+    });
+    if (status === 'failed')
+        state.errors.push(error);
+}
+function makeTraceCapture() {
+    let started = false;
+    let completedTrace;
+    const capture = ((effect) => Effect.suspend(() => {
+        if (started) {
+            return Effect.die(namedError('TestTraceAlreadyCaptured', 'A Laymos Test can capture only one Effect trace'));
+        }
+        started = true;
+        // A test that ends with an open span recorded something incoherent, so
+        // the recorder is asked to reject that rather than report it as running.
+        const recorder = makeTraceRecorder({
+            requireFinishedSpans: true,
+            formatValue: stringify,
+        });
+        return recorder.instrument(effect).pipe(Effect.ensuring(Effect.sync(() => {
+            const { spans, logs } = recorder.snapshot();
+            completedTrace = { spans, logs };
+        })));
+    }));
+    capture.getSpans = (selector) => {
+        if (completedTrace === undefined) {
+            throw namedError('TestTraceNotCaptured', 'Trace evidence is available only after trace(effect) completes');
+        }
+        return selector === undefined
+            ? completedTrace.spans
+            : completedTrace.spans.filter((span) => matchesSpan(span, selector));
+    };
+    capture.getSpanCount = (selector) => capture.getSpans(selector).length;
+    Object.defineProperty(capture, 'completedTrace', {
+        get: () => completedTrace,
+    });
+    return capture;
+}
+function matchesSpan(span, selector) {
+    if (selector.name !== undefined &&
+        (typeof selector.name === 'string'
+            ? span.name !== selector.name
+            : !new RegExp(selector.name.source, selector.name.flags).test(span.name))) {
+        return false;
+    }
+    if (selector.status !== undefined && span.status !== selector.status) {
+        return false;
+    }
+    return Object.entries(selector.attributes ?? {}).every(([key, value]) => valuesEqual(span.attributes[key], testValue(value)));
+}
+function valuesEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return (left.length === right.length &&
+            left.every((value, index) => valuesEqual(value, right[index])));
+    }
+    if (isRecord(left) &&
+        !Array.isArray(left) &&
+        isRecord(right) &&
+        !Array.isArray(right)) {
+        const leftRecord = left;
+        const rightRecord = right;
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        return (leftKeys.length === rightKeys.length &&
+            leftKeys.every((key) => key in right && valuesEqual(leftRecord[key], rightRecord[key])));
+    }
+    return false;
+}
+function testValue(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized !== undefined)
+            return JSON.parse(serialized);
+    }
+    catch { }
+    return stringify(value);
+}
+function errorReport(error) {
+    return {
+        name: error.name || 'Error',
+        message: error.message,
+        ...(error.stack === undefined ? {} : { stack: error.stack }),
+    };
+}
+function namedError(name, message) {
+    return Object.assign(new Error(message), { name });
+}
+function requireText(value, subject) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new TypeError(`${subject} must not be empty`);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isPromiseLike(value) {
+    return isRecord(value) && typeof value.then === 'function';
+}

package/dist/tests/run-tests/index.d.ts

@@ -0,0 +1,3 @@
+export { executeTests, TestRunInProgress, TestRunnerError, } from './run-tests.js';
+export type { TestsRunOptions } from './run-tests.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tests/run-tests/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tests/run-tests/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,eAAe,GAChB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/tests/run-tests/index.js

@@ -0,0 +1 @@
+export { executeTests, TestRunInProgress, TestRunnerError, } from './run-tests.js';

package/dist/tests/run-tests/run-tests.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from 'effect';
+import { type TestErrorReport, type TestsReport } from '../../report/tests.js';
+export interface TestsRunOptions {
+    readonly files?: readonly string[];
+    readonly testNamePattern?: string | RegExp;
+}
+declare const TestRunInProgress_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TestRunInProgress";
+} & Readonly<A>;
+export declare class TestRunInProgress extends TestRunInProgress_base<{
+    readonly projectDir: string;
+    readonly message: string;
+}> {
+}
+declare const TestRunnerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "TestRunnerError";
+} & Readonly<A>;
+export declare class TestRunnerError extends TestRunnerError_base<{
+    readonly message: string;
+    readonly cause: unknown;
+}> {
+}
+export declare function executeTests(projectDir: string, options?: TestsRunOptions): Effect.Effect<TestsReport, TestRunInProgress | TestRunnerError>;
+export declare function mapError(error: unknown): TestErrorReport;
+export {};
+//# sourceMappingURL=run-tests.d.ts.map

package/dist/tests/run-tests/run-tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-tests.d.ts","sourceRoot":"","sources":["../../../src/tests/run-tests/run-tests.ts"],"names":[],"mappings":"AAKA,OAAO,EAAQ,MAAM,EAAkB,MAAM,QAAQ,CAAC;AAUtD,OAAO,EAGL,KAAK,eAAe,EAIpB,KAAK,WAAW,EACjB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC5C;;;;AAED,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;;;;AAEL,qBAAa,eAAgB,SAAQ,qBAAoC;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG;AAqCL,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,eAAoB,GAC5B,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,iBAAiB,GAAG,eAAe,CAAC,CAwBjE;AAqPD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAmBxD"}