@jlnstack/procedure 0.0.2 → 0.0.3

package/src/react.ts

@@ -1,66 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { ReactNode } from "react";
-import { init as coreInit, type InitOptions } from "./core";
-import {
-  createMiddleware,
-  createProcedureBuilder,
-  type InferMiddlewareOutput,
-  type InternalMiddleware,
-  type MergeInput,
-  type Middleware,
-  type ProcedureBuilderFactory,
-  type Run,
-} from "./core-internal";
-
-interface ReactProcedureBuilder<TContext, TInput = Record<string, never>> {
-  use<TInputExt, TMiddleware extends Middleware<TInputExt, TContext, any>>(
-    middleware: TMiddleware,
-  ): ReactProcedureBuilder<
-    InferMiddlewareOutput<TMiddleware>,
-    MergeInput<TInput, TInputExt>
-  >;
-
-  input<TSchema extends StandardSchemaV1>(
-    schema: TSchema,
-  ): ReactProcedureBuilder<
-    TContext,
-    MergeInput<TInput, StandardSchemaV1.InferInput<TSchema>>
-  >;
-
-  run: Run<TContext, TInput>;
-  rsc: Run<TContext, TInput, ReactNode>;
-  serverFn: Run<TContext, TInput>;
-}
-
-const createReactBuilder: ProcedureBuilderFactory = (
-  middlewares: InternalMiddleware[],
-  factory?: ProcedureBuilderFactory,
-) => {
-  const core = createProcedureBuilder(
-    middlewares,
-    factory ?? createReactBuilder,
-  );
-
-  return {
-    ...core,
-    rsc: core.run,
-    serverFn: core.run,
-  };
-};
-
-export const init = <TContext>(options: InitOptions<TContext>) => {
-  const core = coreInit(options);
-  const initialMiddlewares: InternalMiddleware[] = [
-    createMiddleware("INITIAL_CONTEXT", async ({ next }: any) => {
-      return next({ ctx: await options.ctx() });
-    }),
-  ];
-
-  return {
-    middleware: core.middleware,
-    procedure: createReactBuilder(initialMiddlewares) as ReactProcedureBuilder<
-      TContext,
-      Record<string, never>
-    >,
-  };
-};

package/src/types.ts

@@ -1,4 +0,0 @@
-export type Prettify<T> = { [K in keyof T]: T[K] } & {};
-export type Awaitable<T> = T | Promise<T>;
-
-export type IsEmptyObject<T> = T extends Record<string, never> ? true : false;

package/test/core.test-d.ts

@@ -1,89 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { expectTypeOf, test } from "vitest";
-import { init } from "../src/core";
-import type { Middleware } from "../src/core-internal";
-
-const createSchema = <T>(): StandardSchemaV1<T> =>
-  ({
-    "~standard": {
-      version: 1,
-      vendor: "test",
-      validate: () => ({ value: {} as T }),
-    },
-  }) as StandardSchemaV1<T>;
-
-const factory = init({ ctx: () => ({ userId: "123" }) });
-
-test("init - context propagates to procedure", () => {
-  factory.procedure.run(({ ctx }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ userId: string }>();
-  });
-});
-
-test("use - single middleware updates context", () => {
-  const mw: Middleware<
-    unknown,
-    { userId: string },
-    { role: "admin" | "user" }
-  > = ({ next }) => next({ ctx: { role: "admin" } });
-
-  factory.procedure.use(mw).run(({ ctx }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ role: "admin" | "user" }>();
-  });
-});
-
-test("use - array of middlewares merges contexts", () => {
-  const mw1: Middleware<unknown, { userId: string }, { a: number }> = ({
-    next,
-  }) => next({ ctx: { a: 1 } });
-  const mw2: Middleware<unknown, { userId: string }, { b: string }> = ({
-    next,
-  }) => next({ ctx: { b: "hello" } });
-
-  factory.procedure.use([mw1, mw2]).run(({ ctx }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ a: number; b: string }>();
-  });
-});
-
-test("input - schema type added to input", () => {
-  const schema = createSchema<{ name: string }>();
-
-  factory.procedure.input(schema).run(({ input }) => {
-    expectTypeOf(input).toEqualTypeOf<{ name: string }>();
-  });
-});
-
-test("run - without input returns no-arg function", () => {
-  const fn = factory.procedure.run(() => "result");
-  expectTypeOf(fn).toEqualTypeOf<() => Promise<string>>();
-});
-
-test("run - with input returns function with arg", () => {
-  const schema = createSchema<{ id: number }>();
-  const fn = factory.procedure.input(schema).run(({ input }) => input.id);
-  expectTypeOf(fn).toEqualTypeOf<(input: { id: number }) => Promise<number>>();
-});
-
-test("run - with partial input returns function with optional arg", () => {
-  const schema = createSchema<{ id?: number }>();
-  const fn = factory.procedure.input(schema).run(() => "result");
-  expectTypeOf(fn).toEqualTypeOf<
-    (input?: { id?: number }) => Promise<string>
-  >();
-});
-
-test("middleware factory - preserves types", () => {
-  const mw = factory.middleware(({ ctx, input, next }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ userId: string }>();
-    expectTypeOf(input).toEqualTypeOf<unknown>();
-    return next({ ctx: { role: "admin" as const } });
-  });
-
-  expectTypeOf(mw).toEqualTypeOf<
-    Middleware<unknown, { userId: string }, { role: "admin" }>
-  >();
-
-  factory.procedure.use(mw).run(({ ctx }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ role: "admin" }>();
-  });
-});

package/test/core.test.ts

@@ -1,57 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { describe, expect, it } from "vitest";
-import { init } from "../src/core";
-
-const createSchema = <T>(): StandardSchemaV1<T> =>
-  ({
-    "~standard": {
-      version: 1,
-      vendor: "test",
-      validate: (value: unknown) => ({ value: value as T }),
-    },
-  }) as StandardSchemaV1<T>;
-
-const factory = init({ ctx: () => ({ userId: "123" }) });
-
-describe("init", () => {
-  it("provides initial context", async () => {
-    const fn = factory.procedure.run(({ ctx }) => ctx.userId);
-    expect(await fn()).toBe("123");
-  });
-});
-
-describe("use", () => {
-  it("single middleware extends context", async () => {
-    const fn = factory.procedure
-      .use(({ next }) => next({ ctx: { role: "admin" } }))
-      .run(({ ctx }) => ctx.role);
-
-    expect(await fn()).toBe("admin");
-  });
-
-  it("array of middlewares merges contexts", async () => {
-    const fn = factory.procedure
-      .use([
-        ({ next }) => next({ ctx: { a: 1 } }),
-        ({ next }) => next({ ctx: { b: 2 } }),
-      ])
-      .run(({ ctx }) => ctx.a + ctx.b);
-
-    expect(await fn()).toBe(3);
-  });
-});
-
-describe("input", () => {
-  it("passes input to run function", async () => {
-    const schema = createSchema<{ x: number }>();
-    const fn = factory.procedure.input(schema).run(({ input }) => input.x * 2);
-    expect(await fn({ x: 5 })).toBe(10);
-  });
-});
-
-describe("run", () => {
-  it("returns the result", async () => {
-    const fn = factory.procedure.run(() => "hello");
-    expect(await fn()).toBe("hello");
-  });
-});

package/test/next.test-d.ts

@@ -1,177 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { Metadata } from "next";
-import type { ReactNode } from "react";
-import { expectTypeOf, test } from "vitest";
-import { init } from "../src/next";
-
-const createSchema = <T>(): StandardSchemaV1<T> =>
-  ({
-    "~standard": {
-      version: 1,
-      vendor: "test",
-      validate: () => ({ value: {} as T }),
-    },
-  }) as StandardSchemaV1<T>;
-
-const factory = init({ ctx: () => ({ userId: "123" }) });
-
-test("init - context propagates to procedure", () => {
-  factory.procedure.run(({ ctx }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ userId: string }>();
-  });
-});
-
-test("params - adds params to context without schema", () => {
-  factory.procedure.params<{ slug: string }>().run(({ ctx, input }) => {
-    expectTypeOf(ctx).toExtend<{ userId: string; params: { slug: string } }>();
-    return input;
-  });
-});
-
-test("params - adds params to context with schema", () => {
-  const schema = createSchema<{ id: number }>();
-
-  factory.procedure
-    .params<{ id: number }, typeof schema>(schema)
-    .run(({ ctx }) => {
-      expectTypeOf(ctx).toExtend<{ userId: string; params: { id: number } }>();
-    });
-});
-
-test("params - input requires Promise<params>", () => {
-  const fn = factory.procedure
-    .params<{ slug: string }>()
-    .run(({ ctx }) => ctx.params.slug);
-
-  expectTypeOf(fn).toEqualTypeOf<
-    (input: { params: Promise<{ slug: string }> }) => Promise<string>
-  >();
-});
-
-test("searchParams - adds validated searchParams to context", () => {
-  const schema = createSchema<{ page: number; limit: number }>();
-
-  factory.procedure.searchParams(schema).run(({ ctx, input }) => {
-    expectTypeOf(ctx).toExtend<{
-      userId: string;
-      searchParams: { page: number; limit: number };
-    }>();
-    return input;
-  });
-});
-
-test("searchParams - input requires Promise<Record<string, ...>>", () => {
-  const schema = createSchema<{ q: string }>();
-  const fn = factory.procedure
-    .searchParams(schema)
-    .run(({ ctx }) => ctx.searchParams.q);
-
-  expectTypeOf(fn).toEqualTypeOf<
-    (input: {
-      searchParams: Promise<Record<string, string | string[] | undefined>>;
-    }) => Promise<string>
-  >();
-});
-
-test("page - returns ReactNode and accepts page props", () => {
-  const fn = factory.procedure.page(() => null as ReactNode);
-
-  expectTypeOf(fn).toBeFunction();
-});
-
-test("page - context available in page handler", () => {
-  factory.procedure.page(({ ctx }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ userId: string }>();
-    return null;
-  });
-});
-
-test("rsc - returns ReactNode", () => {
-  const fn = factory.procedure.rsc(() => null as ReactNode);
-
-  expectTypeOf(fn).toBeFunction();
-});
-
-test("metadata - returns Metadata type", () => {
-  const fn = factory.procedure.metadata(() => ({ title: "Test" }));
-
-  expectTypeOf(fn).toBeFunction();
-  expectTypeOf(fn).returns.resolves.toExtend<Metadata>();
-});
-
-test("layout - receives children in input", () => {
-  factory.procedure.layout(({ input }) => {
-    expectTypeOf(input).toEqualTypeOf<{ children: ReactNode }>();
-    return null;
-  });
-});
-
-test("layout - function signature", () => {
-  const fn = factory.procedure.layout(() => null as ReactNode);
-
-  expectTypeOf(fn).toBeFunction();
-});
-
-test("layoutMetadata - excludes searchParams from context", () => {
-  const searchSchema = createSchema<{ q: string }>();
-
-  factory.procedure.searchParams(searchSchema).layoutMetadata(({ ctx }) => {
-    expectTypeOf(ctx).toEqualTypeOf<{ userId: string }>();
-    return { title: "Layout" };
-  });
-});
-
-test("staticParams - returns array of params", () => {
-  const fn = factory.procedure
-    .params<{ slug: string }>()
-    .staticParams(() => [{ slug: "a" }, { slug: "b" }]);
-
-  type ParamsArray = { slug: string }[];
-  expectTypeOf(fn).returns.resolves.toEqualTypeOf<ParamsArray>();
-});
-
-test("chaining params and searchParams", () => {
-  const paramsSchema = createSchema<{ id: string }>();
-  const searchSchema = createSchema<{ tab: string }>();
-
-  factory.procedure
-    .params<{ id: string }, typeof paramsSchema>(paramsSchema)
-    .searchParams(searchSchema)
-    .page(({ ctx }) => {
-      expectTypeOf(ctx).toExtend<{
-        userId: string;
-        params: { id: string };
-        searchParams: { tab: string };
-      }>();
-      return null;
-    });
-});
-
-test("middleware preserves input requirements through chain", () => {
-  const mw = factory.middleware(({ next }) =>
-    next({ ctx: { role: "admin" as const } }),
-  );
-
-  factory.procedure
-    .use(mw)
-    .params<{ slug: string }>()
-    .page(({ ctx }) => {
-      expectTypeOf(ctx).toExtend<{ role: "admin"; params: { slug: string } }>();
-      return null;
-    });
-});
-
-test("middleware chain - function signature with middleware and params", () => {
-  const mw = factory.middleware(({ next }) =>
-    next({ ctx: { role: "admin" as const } }),
-  );
-
-  const fn = factory.procedure
-    .use(mw)
-    .params<{ slug: string }>()
-    .run(({ ctx }) => ctx.params.slug);
-
-  expectTypeOf(fn).toEqualTypeOf<
-    (input: { params: Promise<{ slug: string }> }) => Promise<string>
-  >();
-});

package/test/next.test.ts

@@ -1,230 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { describe, expect, it } from "vitest";
-import { init } from "../src/next";
-
-const createSchema = <T>(): StandardSchemaV1<T> =>
-  ({
-    "~standard": {
-      version: 1,
-      vendor: "test",
-      validate: (value: unknown) => ({ value: value as T }),
-    },
-  }) as StandardSchemaV1<T>;
-
-const createFailingSchema = <T>(): StandardSchemaV1<T> =>
-  ({
-    "~standard": {
-      version: 1,
-      vendor: "test",
-      validate: () => ({ issues: [{ message: "Invalid" }] }),
-    },
-  }) as StandardSchemaV1<T>;
-
-const factory = init({ ctx: () => ({ userId: "123" }) });
-
-describe("init", () => {
-  it("provides initial context", async () => {
-    const fn = factory.procedure.run(({ ctx }) => ctx.userId);
-    expect(await (fn as () => Promise<string>)()).toBe("123");
-  });
-
-  it("returns middleware factory", () => {
-    const mw = factory.middleware(({ next }) =>
-      next({ ctx: { role: "admin" } }),
-    );
-    expect(typeof mw).toBe("function");
-  });
-});
-
-describe("params", () => {
-  it("unwraps params promise and adds to context", async () => {
-    const fn = factory.procedure
-      .params<{ slug: string }>()
-      .run(({ ctx }) => ctx.params.slug);
-
-    const result = await fn({ params: Promise.resolve({ slug: "hello" }) });
-    expect(result).toBe("hello");
-  });
-
-  it("works with schema validation", async () => {
-    const schema = createSchema<{ id: string }>();
-    const fn = factory.procedure
-      .params<{ id: string }, typeof schema>(schema)
-      .run(({ ctx }) => ctx.params.id);
-
-    const result = await fn({ params: Promise.resolve({ id: "42" }) });
-    expect(result).toBe("42");
-  });
-});
-
-describe("searchParams", () => {
-  it("validates and adds searchParams to context", async () => {
-    const schema = createSchema<{ page: string }>();
-    const fn = factory.procedure
-      .searchParams(schema)
-      .run(({ ctx }) => ctx.searchParams.page);
-
-    const result = await fn({ searchParams: Promise.resolve({ page: "1" }) });
-    expect(result).toBe("1");
-  });
-
-  it("throws on invalid searchParams", async () => {
-    const schema = createFailingSchema<{ page: string }>();
-    const fn = factory.procedure
-      .searchParams(schema)
-      .run(({ ctx }) => ctx.searchParams.page);
-
-    await expect(
-      fn({ searchParams: Promise.resolve({ page: "1" }) }),
-    ).rejects.toThrow("Invalid search params");
-  });
-});
-
-describe("page", () => {
-  it("is an alias for run", async () => {
-    const fn = factory.procedure.page(({ ctx }) => `user-${ctx.userId}`);
-    const result = await fn({
-      searchParams: Promise.resolve({}),
-      params: Promise.resolve({}),
-    });
-    expect(result).toBe("user-123");
-  });
-
-  it("works with params and searchParams", async () => {
-    const paramsSchema = createSchema<{ slug: string }>();
-    const searchSchema = createSchema<{ q: string }>();
-
-    const fn = factory.procedure
-      .params<{ slug: string }, typeof paramsSchema>(paramsSchema)
-      .searchParams(searchSchema)
-      .page(({ ctx }) => `${ctx.params.slug}-${ctx.searchParams.q}`);
-
-    const result = await fn({
-      params: Promise.resolve({ slug: "post" }),
-      searchParams: Promise.resolve({ q: "test" }),
-    });
-    expect(result).toBe("post-test");
-  });
-});
-
-describe("rsc", () => {
-  it("executes and returns value", async () => {
-    const fn = factory.procedure.rsc(() => "RSC Content");
-    expect(await (fn as () => Promise<string>)()).toBe("RSC Content");
-  });
-});
-
-describe("metadata", () => {
-  it("returns Metadata object", async () => {
-    const fn = factory.procedure.metadata(() => ({ title: "My Page" }));
-    expect(await (fn as () => Promise<{ title: string }>)()).toEqual({
-      title: "My Page",
-    });
-  });
-
-  it("can access context for dynamic metadata", async () => {
-    const fn = factory.procedure.metadata(({ ctx }) => ({
-      title: `User ${ctx.userId}`,
-    }));
-    expect(await (fn as () => Promise<{ title: string }>)()).toEqual({
-      title: "User 123",
-    });
-  });
-});
-
-describe("layout", () => {
-  it("receives children in input", async () => {
-    const fn = factory.procedure.layout(
-      ({ input }) => `wrapped: ${input.children}`,
-    );
-
-    const result = await fn({ children: "Content" });
-    expect(result).toBe("wrapped: Content");
-  });
-});
-
-describe("layoutMetadata", () => {
-  it("returns Metadata for layouts", async () => {
-    const fn = factory.procedure.layoutMetadata(() => ({
-      description: "Layout desc",
-    }));
-    expect(await (fn as () => Promise<{ description: string }>)()).toEqual({
-      description: "Layout desc",
-    });
-  });
-});
-
-describe("staticParams", () => {
-  it("returns array of params for static generation", async () => {
-    const fn = factory.procedure
-      .params<{ slug: string }>()
-      .staticParams(() => [{ slug: "post-1" }, { slug: "post-2" }]);
-
-    const result = await fn({ params: Promise.resolve({ slug: "" }) });
-    expect(result).toEqual([{ slug: "post-1" }, { slug: "post-2" }]);
-  });
-});
-
-describe("chaining", () => {
-  it("chains params with middleware", async () => {
-    const authMiddleware = factory.middleware(({ ctx, next }) =>
-      next({ ctx: { ...ctx, isAuth: true } }),
-    );
-
-    const fn = factory.procedure
-      .use(authMiddleware)
-      .params<{ id: string }>()
-      .page(({ ctx }) => `${ctx.isAuth}-${ctx.params.id}`);
-
-    const result = await fn({
-      params: Promise.resolve({ id: "42" }),
-      searchParams: Promise.resolve({}),
-    });
-    expect(result).toBe("true-42");
-  });
-
-  it("chains multiple middlewares with next-specific methods", async () => {
-    const mw1 = factory.middleware(({ next }) => next({ ctx: { a: 1 } }));
-    const mw2 = factory.middleware(({ next }) => next({ ctx: { b: 2 } }));
-
-    const fn = factory.procedure
-      .use([mw1, mw2])
-      .params<{ slug: string }>()
-      .searchParams(createSchema<{ q: string }>())
-      .page(({ ctx }) => ctx.a + ctx.b);
-
-    const result = await (fn as any)({
-      params: Promise.resolve({ slug: "test" }),
-      searchParams: Promise.resolve({ q: "query" }),
-    });
-    expect(result).toBe(3);
-  });
-
-  it("preserves context through entire chain", async () => {
-    const fn = factory.procedure
-      .use(({ next }) => next({ ctx: { step1: true } }))
-      .use(({ ctx, next }) => next({ ctx: { ...ctx, step2: true } }))
-      .params<{ id: string }>()
-      .page(({ ctx }) => `${ctx.step1}-${ctx.step2}-${ctx.params.id}`);
-
-    const result = await fn({
-      params: Promise.resolve({ id: "test" }),
-      searchParams: Promise.resolve({}),
-    });
-    expect(result).toBe("true-true-test");
-  });
-});
-
-describe("async context", () => {
-  it("handles async initial context", async () => {
-    const asyncFactory = init({
-      ctx: async () => {
-        await Promise.resolve();
-        return { asyncValue: "loaded" };
-      },
-    });
-
-    const fn = asyncFactory.procedure.run(({ ctx }) => ctx.asyncValue);
-    expect(await (fn as () => Promise<string>)()).toBe("loaded");
-  });
-});

package/tsconfig.build.json

@@ -1,7 +0,0 @@
-{
-  "extends": "../../tsconfig.build.json",
-  "compilerOptions": {
-    "declarationDir": "dist"
-  },
-  "include": ["src"]
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "include": ["src", "test"],
-  "compilerOptions": {}
-}

package/tsdown.config.ts

@@ -1,23 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export const input = [
-  "src/index.ts",
-  "src/core.ts",
-  "src/react.ts",
-  "src/next.ts",
-];
-
-export default defineConfig({
-  target: ["node18", "es2017"],
-  entry: input,
-  dts: {
-    sourcemap: true,
-    tsconfig: "./tsconfig.build.json",
-  },
-  unbundle: true,
-  format: ["cjs", "esm"],
-  outExtensions: (ctx) => ({
-    dts: ctx.format === "cjs" ? ".d.cts" : ".d.mts",
-    js: ctx.format === "cjs" ? ".cjs" : ".mjs",
-  }),
-});

package/vitest.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    exclude: ["node_modules", "dist"],
-    typecheck: {
-      enabled: true,
-    },
-  },
-});