@jlnstack/procedure 0.0.1

package/dist/next.d.mts

@@ -0,0 +1,47 @@
+import { Prettify } from "./types.mjs";
+import { InferMiddlewareArrayInput, InferMiddlewareArrayOutput, InferMiddlewareOutput, MergeInput, Middleware, Run } from "./core-internal.mjs";
+import { InitOptions } from "./core.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { Metadata } from "next";
+import { ReactNode } from "react";
+
+//#region src/next.d.ts
+type ExtractParams<TInput> = TInput extends {
+  params: infer P;
+} ? P : never;
+interface NextProcedureBuilder<TContext, TInput = {}> {
+  use<TInputExt, TMiddleware extends Middleware<TInputExt, TContext, any>>(middleware: TMiddleware): NextProcedureBuilder<InferMiddlewareOutput<TMiddleware>, MergeInput<TInput, TInputExt>>;
+  use<TMiddlewares extends readonly Middleware<any, TContext, any>[]>(middlewares: [...TMiddlewares]): NextProcedureBuilder<InferMiddlewareArrayOutput<TMiddlewares>, MergeInput<TInput, InferMiddlewareArrayInput<TMiddlewares>>>;
+  input<TSchema extends StandardSchemaV1>(schema: TSchema): NextProcedureBuilder<TContext, TInput & StandardSchemaV1.InferInput<TSchema>>;
+  params<T, TSchema extends StandardSchemaV1 | undefined = undefined>(schema?: TSchema): NextProcedureBuilder<Prettify<TContext & {
+    params: TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : T;
+  }>, Prettify<TInput & {
+    params: Promise<TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : T>;
+  }>>;
+  searchParams<TSchema extends StandardSchemaV1>(schema: TSchema): NextProcedureBuilder<Prettify<TContext & {
+    searchParams: StandardSchemaV1.InferOutput<TSchema>;
+  }>, Prettify<TInput & {
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+  }>>;
+  run: Run<TContext, TInput>;
+  page: Run<TContext, Prettify<TInput & {
+    searchParams: Promise<Record<string, string | string[] | undefined>>;
+    params: Promise<{
+      [key: string]: string;
+    }>;
+  }>, ReactNode>;
+  rsc: Run<TContext, TInput, ReactNode>;
+  metadata: Run<TContext, TInput, Metadata>;
+  layout: Run<TContext, TInput & {
+    children: ReactNode;
+  }, ReactNode>;
+  layoutMetadata: Run<Prettify<Omit<TContext, "searchParams">>, Prettify<Omit<TInput, "searchParams">>, Metadata>;
+  staticParams: Run<TContext, TInput, ExtractParams<TContext>[]>;
+}
+declare const init: <TContext>(options: InitOptions<TContext>) => {
+  middleware: <TInput, TResult>(fn: Middleware<TInput, TContext, TResult>) => Middleware<TInput, TContext, TResult>;
+  procedure: NextProcedureBuilder<TContext>;
+};
+//#endregion
+export { init };
+//# sourceMappingURL=next.d.mts.map

package/dist/next.d.mts.map

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

package/dist/next.mjs

@@ -0,0 +1,46 @@
+import { _objectSpread2 } from "./_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.mjs";
+import { createMiddleware, createProcedureBuilder } from "./core-internal.mjs";
+import { init as init$1 } from "./core.mjs";
+
+//#region src/next.ts
+const createNextBuilder = (middlewares, factory) => {
+	const core = createProcedureBuilder(middlewares, factory !== null && factory !== void 0 ? factory : createNextBuilder);
+	return _objectSpread2(_objectSpread2({}, core), {}, {
+		params() {
+			const mw = createMiddleware("NEXT_PARAMS", async ({ input, ctx, next }) => {
+				const params = await input.params;
+				return next({ ctx: _objectSpread2(_objectSpread2({}, ctx), {}, { params }) });
+			});
+			return createNextBuilder([...middlewares, mw], factory);
+		},
+		searchParams(schema) {
+			const mw = createMiddleware("NEXT_SEARCH_PARAMS", async ({ input, ctx, next }) => {
+				const searchParams = await input.searchParams;
+				const result = await schema["~standard"].validate(searchParams);
+				if (result.issues) throw new Error("Invalid search params");
+				return next({ ctx: _objectSpread2(_objectSpread2({}, ctx), {}, { searchParams: result.value }) });
+			});
+			return createNextBuilder([...middlewares, mw], factory);
+		},
+		page: core.run,
+		rsc: core.run,
+		metadata: core.run,
+		layout: core.run,
+		layoutMetadata: core.run,
+		staticParams: core.run
+	});
+};
+const init = (options) => {
+	const core = init$1(options);
+	const initialMiddlewares = [createMiddleware("INITIAL_CONTEXT", async ({ next }) => {
+		return next({ ctx: await options.ctx() });
+	})];
+	return {
+		middleware: core.middleware,
+		procedure: createNextBuilder(initialMiddlewares)
+	};
+};
+
+//#endregion
+export { init };
+//# sourceMappingURL=next.mjs.map

package/dist/next.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.mjs","names":["createNextBuilder: ProcedureBuilderFactory","coreInit","initialMiddlewares: InternalMiddleware[]"],"sources":["../src/next.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { Metadata } from \"next\";\nimport type { ReactNode } from \"react\";\nimport { init as coreInit, type InitOptions } from \"./core\";\nimport {\n  createMiddleware,\n  createProcedureBuilder,\n  type InferMiddlewareArrayInput,\n  type InferMiddlewareArrayOutput,\n  type InferMiddlewareOutput,\n  type InternalMiddleware,\n  type MergeInput,\n  type Middleware,\n  type ProcedureBuilderFactory,\n  type Run,\n} from \"./core-internal\";\nimport type { Prettify } from \"./types\";\n\ntype ExtractParams<TInput> = TInput extends { params: infer P } ? P : never;\n\ninterface NextProcedureBuilder<TContext, TInput = {}> {\n  use<TInputExt, TMiddleware extends Middleware<TInputExt, TContext, any>>(\n    middleware: TMiddleware,\n  ): NextProcedureBuilder<\n    InferMiddlewareOutput<TMiddleware>,\n    MergeInput<TInput, TInputExt>\n  >;\n\n  use<TMiddlewares extends readonly Middleware<any, TContext, any>[]>(\n    middlewares: [...TMiddlewares],\n  ): NextProcedureBuilder<\n    InferMiddlewareArrayOutput<TMiddlewares>,\n    MergeInput<TInput, InferMiddlewareArrayInput<TMiddlewares>>\n  >;\n\n  input<TSchema extends StandardSchemaV1>(\n    schema: TSchema,\n  ): NextProcedureBuilder<\n    TContext,\n    TInput & StandardSchemaV1.InferInput<TSchema>\n  >;\n\n  params<T, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    schema?: TSchema,\n  ): NextProcedureBuilder<\n    Prettify<\n      TContext & {\n        params: TSchema extends StandardSchemaV1\n          ? StandardSchemaV1.InferOutput<TSchema>\n          : T;\n      }\n    >,\n    Prettify<\n      TInput & {\n        params: Promise<\n          TSchema extends StandardSchemaV1\n            ? StandardSchemaV1.InferOutput<TSchema>\n            : T\n        >;\n      }\n    >\n  >;\n\n  searchParams<TSchema extends StandardSchemaV1>(\n    schema: TSchema,\n  ): NextProcedureBuilder<\n    Prettify<\n      TContext & { searchParams: StandardSchemaV1.InferOutput<TSchema> }\n    >,\n    Prettify<\n      TInput & {\n        searchParams: Promise<Record<string, string | string[] | undefined>>;\n      }\n    >\n  >;\n\n  run: Run<TContext, TInput>;\n  page: Run<\n    TContext,\n    Prettify<\n      TInput & {\n        searchParams: Promise<Record<string, string | string[] | undefined>>;\n        params: Promise<{ [key: string]: string }>;\n      }\n    >,\n    ReactNode\n  >;\n  rsc: Run<TContext, TInput, ReactNode>;\n  metadata: Run<TContext, TInput, Metadata>;\n  layout: Run<TContext, TInput & { children: ReactNode }, ReactNode>;\n  layoutMetadata: Run<\n    Prettify<Omit<TContext, \"searchParams\">>,\n    Prettify<Omit<TInput, \"searchParams\">>,\n    Metadata\n  >;\n\n  staticParams: Run<TContext, TInput, ExtractParams<TContext>[]>;\n}\n\nconst createNextBuilder: ProcedureBuilderFactory = (\n  middlewares: InternalMiddleware[],\n  factory?: ProcedureBuilderFactory,\n) => {\n  const core = createProcedureBuilder(\n    middlewares,\n    factory ?? createNextBuilder,\n  );\n\n  return {\n    ...core,\n\n    params() {\n      const mw = createMiddleware(\n        \"NEXT_PARAMS\",\n        async ({ input, ctx, next }: any) => {\n          const params = await input.params;\n\n          return next({ ctx: { ...ctx, params } });\n        },\n      );\n      return createNextBuilder([...middlewares, mw], factory) as any;\n    },\n\n    searchParams(schema: StandardSchemaV1) {\n      const mw = createMiddleware(\n        \"NEXT_SEARCH_PARAMS\",\n        async ({ input, ctx, next }: any) => {\n          const searchParams = await input.searchParams;\n\n          const result = await schema[\"~standard\"].validate(searchParams);\n          if (result.issues) throw new Error(\"Invalid search params\");\n          return next({ ctx: { ...ctx, searchParams: result.value } });\n        },\n      );\n      return createNextBuilder([...middlewares, mw], factory) as any;\n    },\n\n    page: core.run,\n    rsc: core.run,\n    metadata: core.run,\n    layout: core.run,\n    layoutMetadata: core.run,\n    staticParams: core.run,\n  } as any;\n};\n\nexport const init = <TContext>(options: InitOptions<TContext>) => {\n  const core = coreInit(options);\n  const initialMiddlewares: InternalMiddleware[] = [\n    createMiddleware(\"INITIAL_CONTEXT\", async ({ next }: any) => {\n      return next({ ctx: await options.ctx() });\n    }),\n  ];\n\n  return {\n    middleware: core.middleware,\n    procedure: createNextBuilder(\n      initialMiddlewares,\n    ) as unknown as NextProcedureBuilder<TContext>,\n  };\n};\n"],"mappings":";;;;;AAmGA,MAAMA,qBACJ,aACA,YACG;CACH,MAAM,OAAO,uBACX,aACA,mDAAW,kBACZ;AAED,0CACK;EAEH,SAAS;GACP,MAAM,KAAK,iBACT,eACA,OAAO,EAAE,OAAO,KAAK,WAAgB;IACnC,MAAM,SAAS,MAAM,MAAM;AAE3B,WAAO,KAAK,EAAE,uCAAU,YAAK,WAAU,CAAC;KAE3C;AACD,UAAO,kBAAkB,CAAC,GAAG,aAAa,GAAG,EAAE,QAAQ;;EAGzD,aAAa,QAA0B;GACrC,MAAM,KAAK,iBACT,sBACA,OAAO,EAAE,OAAO,KAAK,WAAgB;IACnC,MAAM,eAAe,MAAM,MAAM;IAEjC,MAAM,SAAS,MAAM,OAAO,aAAa,SAAS,aAAa;AAC/D,QAAI,OAAO,OAAQ,OAAM,IAAI,MAAM,wBAAwB;AAC3D,WAAO,KAAK,EAAE,uCAAU,YAAK,cAAc,OAAO,UAAS,CAAC;KAE/D;AACD,UAAO,kBAAkB,CAAC,GAAG,aAAa,GAAG,EAAE,QAAQ;;EAGzD,MAAM,KAAK;EACX,KAAK,KAAK;EACV,UAAU,KAAK;EACf,QAAQ,KAAK;EACb,gBAAgB,KAAK;EACrB,cAAc,KAAK;;;AAIvB,MAAa,QAAkB,YAAmC;CAChE,MAAM,OAAOC,OAAS,QAAQ;CAC9B,MAAMC,qBAA2C,CAC/C,iBAAiB,mBAAmB,OAAO,EAAE,WAAgB;AAC3D,SAAO,KAAK,EAAE,KAAK,MAAM,QAAQ,KAAK,EAAE,CAAC;GACzC,CACH;AAED,QAAO;EACL,YAAY,KAAK;EACjB,WAAW,kBACT,mBACD;EACF"}

package/dist/react.cjs

@@ -0,0 +1,25 @@
+const require_objectSpread2 = require('./_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_core_internal = require('./core-internal.cjs');
+const require_core = require('./core.cjs');
+
+//#region src/react.ts
+const createReactBuilder = (middlewares, factory) => {
+	const core = require_core_internal.createProcedureBuilder(middlewares, factory !== null && factory !== void 0 ? factory : createReactBuilder);
+	return require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, core), {}, {
+		rsc: core.run,
+		serverFn: core.run
+	});
+};
+const init = (options) => {
+	const core = require_core.init(options);
+	const initialMiddlewares = [require_core_internal.createMiddleware("INITIAL_CONTEXT", async ({ next }) => {
+		return next({ ctx: await options.ctx() });
+	})];
+	return {
+		middleware: core.middleware,
+		procedure: createReactBuilder(initialMiddlewares)
+	};
+};
+
+//#endregion
+exports.init = init;

package/dist/react.d.cts

@@ -0,0 +1,20 @@
+import { InferMiddlewareOutput, MergeInput, Middleware, Run } from "./core-internal.cjs";
+import { InitOptions } from "./core.cjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { ReactNode } from "react";
+
+//#region src/react.d.ts
+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>;
+}
+declare const init: <TContext>(options: InitOptions<TContext>) => {
+  middleware: <TInput, TResult>(fn: Middleware<TInput, TContext, TResult>) => Middleware<TInput, TContext, TResult>;
+  procedure: ReactProcedureBuilder<TContext, Record<string, never>>;
+};
+//#endregion
+export { init };
+//# sourceMappingURL=react.d.cts.map

package/dist/react.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.cts","names":[],"sources":["../src/react.ts"],"sourcesContent":[],"mappings":";;;;;;UAcU,yCAAyC;qCACd,WAAW,WAAW,4BAC3C,cACX,sBACD,sBAAsB,cACtB,WAAW,QAAQ;EALb,KAAA,CAAA,gBAQc,gBARO,CAAA,CAAA,MAAA,EASnB,OATmB,CAAA,EAU1B,qBAV0B,CAW3B,QAX2B,EAY3B,UAZ2B,CAYhB,MAZgB,EAYR,gBAAA,CAAiB,UAZT,CAYoB,OAZpB,CAAA,CAAA,CAAA;EAAA,GAAA,EAexB,GAfwB,CAepB,QAfoB,EAeV,MAfU,CAAA;KAAoB,EAgB5C,GAhB4C,CAgBxC,QAhBwC,EAgB9B,MAhB8B,EAgBtB,SAhBsB,CAAA;UACH,EAgBpC,GAhBoC,CAgBhC,QAhBgC,EAgBtB,MAhBsB,CAAA;;AAAX,cAmCxB,IAnCwB,EAAA,CAAA,QAAA,CAAA,CAAA,OAAA,EAmCG,WAnCH,CAmCe,QAnCf,CAAA,EAAA,GAAA;YACrB,EAAA,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAAA,YAAA,OAAA,UAAA,SAAA,CAAA,EAAA,aAAA,OAAA,UAAA,SAAA,CAAA;WAEU,EA0C+B,qBA1C/B,CA2CpB,QA3CoB,EA4CpB,MA5CoB,CAAA,MAAA,EAAA,KAAA,CAAA,CAAA"}

package/dist/react.d.mts

@@ -0,0 +1,20 @@
+import { InferMiddlewareOutput, MergeInput, Middleware, Run } from "./core-internal.mjs";
+import { InitOptions } from "./core.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { ReactNode } from "react";
+
+//#region src/react.d.ts
+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>;
+}
+declare const init: <TContext>(options: InitOptions<TContext>) => {
+  middleware: <TInput, TResult>(fn: Middleware<TInput, TContext, TResult>) => Middleware<TInput, TContext, TResult>;
+  procedure: ReactProcedureBuilder<TContext, Record<string, never>>;
+};
+//#endregion
+export { init };
+//# sourceMappingURL=react.d.mts.map

package/dist/react.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.mts","names":[],"sources":["../src/react.ts"],"sourcesContent":[],"mappings":";;;;;;UAcU,yCAAyC;qCACd,WAAW,WAAW,4BAC3C,cACX,sBACD,sBAAsB,cACtB,WAAW,QAAQ;EALb,KAAA,CAAA,gBAQc,gBARO,CAAA,CAAA,MAAA,EASnB,OATmB,CAAA,EAU1B,qBAV0B,CAW3B,QAX2B,EAY3B,UAZ2B,CAYhB,MAZgB,EAYR,gBAAA,CAAiB,UAZT,CAYoB,OAZpB,CAAA,CAAA,CAAA;EAAA,GAAA,EAexB,GAfwB,CAepB,QAfoB,EAeV,MAfU,CAAA;KAAoB,EAgB5C,GAhB4C,CAgBxC,QAhBwC,EAgB9B,MAhB8B,EAgBtB,SAhBsB,CAAA;UACH,EAgBpC,GAhBoC,CAgBhC,QAhBgC,EAgBtB,MAhBsB,CAAA;;AAAX,cAmCxB,IAnCwB,EAAA,CAAA,QAAA,CAAA,CAAA,OAAA,EAmCG,WAnCH,CAmCe,QAnCf,CAAA,EAAA,GAAA;YACrB,EAAA,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,EAAA,YAAA,OAAA,UAAA,SAAA,CAAA,EAAA,aAAA,OAAA,UAAA,SAAA,CAAA;WAEU,EA0C+B,qBA1C/B,CA2CpB,QA3CoB,EA4CpB,MA5CoB,CAAA,MAAA,EAAA,KAAA,CAAA,CAAA"}

package/dist/react.mjs

@@ -0,0 +1,26 @@
+import { _objectSpread2 } from "./_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.mjs";
+import { createMiddleware, createProcedureBuilder } from "./core-internal.mjs";
+import { init as init$1 } from "./core.mjs";
+
+//#region src/react.ts
+const createReactBuilder = (middlewares, factory) => {
+	const core = createProcedureBuilder(middlewares, factory !== null && factory !== void 0 ? factory : createReactBuilder);
+	return _objectSpread2(_objectSpread2({}, core), {}, {
+		rsc: core.run,
+		serverFn: core.run
+	});
+};
+const init = (options) => {
+	const core = init$1(options);
+	const initialMiddlewares = [createMiddleware("INITIAL_CONTEXT", async ({ next }) => {
+		return next({ ctx: await options.ctx() });
+	})];
+	return {
+		middleware: core.middleware,
+		procedure: createReactBuilder(initialMiddlewares)
+	};
+};
+
+//#endregion
+export { init };
+//# sourceMappingURL=react.mjs.map

package/dist/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","names":["createReactBuilder: ProcedureBuilderFactory","coreInit","initialMiddlewares: InternalMiddleware[]"],"sources":["../src/react.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { ReactNode } from \"react\";\nimport { init as coreInit, type InitOptions } from \"./core\";\nimport {\n  createMiddleware,\n  createProcedureBuilder,\n  type InferMiddlewareOutput,\n  type InternalMiddleware,\n  type MergeInput,\n  type Middleware,\n  type ProcedureBuilderFactory,\n  type Run,\n} from \"./core-internal\";\n\ninterface ReactProcedureBuilder<TContext, TInput = Record<string, never>> {\n  use<TInputExt, TMiddleware extends Middleware<TInputExt, TContext, any>>(\n    middleware: TMiddleware,\n  ): ReactProcedureBuilder<\n    InferMiddlewareOutput<TMiddleware>,\n    MergeInput<TInput, TInputExt>\n  >;\n\n  input<TSchema extends StandardSchemaV1>(\n    schema: TSchema,\n  ): ReactProcedureBuilder<\n    TContext,\n    MergeInput<TInput, StandardSchemaV1.InferInput<TSchema>>\n  >;\n\n  run: Run<TContext, TInput>;\n  rsc: Run<TContext, TInput, ReactNode>;\n  serverFn: Run<TContext, TInput>;\n}\n\nconst createReactBuilder: ProcedureBuilderFactory = (\n  middlewares: InternalMiddleware[],\n  factory?: ProcedureBuilderFactory,\n) => {\n  const core = createProcedureBuilder(\n    middlewares,\n    factory ?? createReactBuilder,\n  );\n\n  return {\n    ...core,\n    rsc: core.run,\n    serverFn: core.run,\n  };\n};\n\nexport const init = <TContext>(options: InitOptions<TContext>) => {\n  const core = coreInit(options);\n  const initialMiddlewares: InternalMiddleware[] = [\n    createMiddleware(\"INITIAL_CONTEXT\", async ({ next }: any) => {\n      return next({ ctx: await options.ctx() });\n    }),\n  ];\n\n  return {\n    middleware: core.middleware,\n    procedure: createReactBuilder(initialMiddlewares) as ReactProcedureBuilder<\n      TContext,\n      Record<string, never>\n    >,\n  };\n};\n"],"mappings":";;;;;AAkCA,MAAMA,sBACJ,aACA,YACG;CACH,MAAM,OAAO,uBACX,aACA,mDAAW,mBACZ;AAED,0CACK;EACH,KAAK,KAAK;EACV,UAAU,KAAK;;;AAInB,MAAa,QAAkB,YAAmC;CAChE,MAAM,OAAOC,OAAS,QAAQ;CAC9B,MAAMC,qBAA2C,CAC/C,iBAAiB,mBAAmB,OAAO,EAAE,WAAgB;AAC3D,SAAO,KAAK,EAAE,KAAK,MAAM,QAAQ,KAAK,EAAE,CAAC;GACzC,CACH;AAED,QAAO;EACL,YAAY,KAAK;EACjB,WAAW,mBAAmB,mBAAmB;EAIlD"}

package/dist/types.d.cts

@@ -0,0 +1,6 @@
+//#region src/types.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Awaitable<T> = T | Promise<T>;
+//#endregion
+export { Awaitable, Prettify };
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";KAAY,sBAAA,MAA4B,CAApB,GAAwB,CAAxB,CAA0B,CAA1B,CAAA,EAAA,GAAA,CAAA,CAAA;AAAoB,KAC5B,SAD4B,CAAA,CAAA,CAAA,GACb,CADa,GACT,OADS,CACD,CADC,CAAA"}

package/dist/types.d.mts

@@ -0,0 +1,6 @@
+//#region src/types.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Awaitable<T> = T | Promise<T>;
+//#endregion
+export { Awaitable, Prettify };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";KAAY,sBAAA,MAA4B,CAApB,GAAwB,CAAxB,CAA0B,CAA1B,CAAA,EAAA,GAAA,CAAA,CAAA;AAAoB,KAC5B,SAD4B,CAAA,CAAA,CAAA,GACb,CADa,GACT,OADS,CACD,CADC,CAAA"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@jlnstack/procedure",
+  "description": "",
+  "version": "0.0.1",
+  "license": "MIT",
+  "author": "jln13x",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:ui": "vitest --ui"
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-dom": ">=19",
+    "next": ">=16"
+  },
+  "devDependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.1.0",
+    "@types/react": "^19.1.16",
+    "@types/react-dom": "^19.1.9",
+    "@vitest/ui": "^2.1.8",
+    "tsdown": "^0.15.4",
+    "typescript": "catalog:",
+    "vitest": "^2.1.8"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./react": {
+      "import": {
+        "types": "./dist/react.d.mts",
+        "default": "./dist/react.mjs"
+      },
+      "require": {
+        "types": "./dist/react.d.cts",
+        "default": "./dist/react.cjs"
+      }
+    },
+    "./next": {
+      "import": {
+        "types": "./dist/next.d.mts",
+        "default": "./dist/next.mjs"
+      },
+      "require": {
+        "types": "./dist/next.d.cts",
+        "default": "./dist/next.cjs"
+      }
+    }
+  }
+}

package/src/core-internal.ts

@@ -0,0 +1,206 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { Awaitable, Prettify } from "./types";
+
+export interface MiddlewareResult<TCtx> {
+  result: unknown;
+  ctx: TCtx;
+}
+
+export type Middleware<TInput, TContext, TResult> = (args: {
+  input: TInput;
+  ctx: TContext;
+  next: <T>(opts: { ctx: T }) => Awaitable<MiddlewareResult<T>>;
+}) => Awaitable<MiddlewareResult<TResult>>;
+
+export interface InternalMiddleware {
+  id?: string;
+  run: Middleware<any, any, any>;
+}
+
+export type InferMiddlewareOutput<T> = T extends Middleware<any, any, infer O>
+  ? O
+  : never;
+
+export type InferMiddlewareArrayOutput<
+  T extends readonly Middleware<any, any, any>[],
+> = T extends readonly [infer First, ...infer Rest]
+  ? First extends Middleware<any, any, infer O>
+    ? Rest extends readonly Middleware<any, any, any>[]
+      ? Prettify<O & InferMiddlewareArrayOutput<Rest>>
+      : O
+    : never
+  : {};
+
+export type InferMiddlewareArrayInput<
+  T extends readonly Middleware<any, any, any>[],
+> = T extends readonly [infer First, ...infer Rest]
+  ? First extends Middleware<infer I, any, any>
+    ? Rest extends readonly Middleware<any, any, any>[]
+      ? MergeInput<I, InferMiddlewareArrayInput<Rest>>
+      : I
+    : never
+  : Record<string, never>;
+
+export type MergeInput<A, B> = Prettify<
+  (A extends Record<string, never> | undefined ? {} : A) &
+    (B extends Record<string, never> | undefined ? {} : B)
+>;
+
+export interface ProcedureBuilder<TContext, TInput = Record<string, never>> {
+  use<TInputExt, TMiddleware extends Middleware<TInputExt, TContext, any>>(
+    middleware: TMiddleware,
+  ): ProcedureBuilder<
+    InferMiddlewareOutput<TMiddleware>,
+    MergeInput<TInput, TInputExt>
+  >;
+
+  use<TMiddlewares extends readonly Middleware<any, TContext, any>[]>(
+    middlewares: [...TMiddlewares],
+  ): ProcedureBuilder<
+    InferMiddlewareArrayOutput<TMiddlewares>,
+    MergeInput<TInput, InferMiddlewareArrayInput<TMiddlewares>>
+  >;
+
+  input<TSchema extends StandardSchemaV1>(
+    schema: TSchema,
+  ): ProcedureBuilder<
+    TContext,
+    MergeInput<TInput, StandardSchemaV1.InferInput<TSchema>>
+  >;
+
+  run: Run<TContext, TInput>;
+}
+
+type IsPartialObject<T> = T extends object
+  ? {} extends T
+    ? true
+    : false
+  : false;
+
+export type Run<
+  TContext,
+  TInput = Record<string, never>,
+  TResultConstraint = unknown,
+> = <TResult extends TResultConstraint>(
+  fn: (args: { input: TInput; ctx: TContext }) => Awaitable<TResult>,
+) => TInput extends Record<string, never> | undefined
+  ? () => Promise<TResult>
+  : IsPartialObject<TInput> extends true
+    ? (input?: TInput) => Promise<TResult>
+    : (input: TInput) => Promise<TResult>;
+
+export type ProcedureBuilderFactory = (
+  mws: InternalMiddleware[],
+  factory?: ProcedureBuilderFactory,
+) => ProcedureBuilder<any, any>;
+
+export const createProcedureBuilder = <
+  TContext,
+  TInput = Record<string, never>,
+>(
+  middlewares: InternalMiddleware[],
+  factory?: ProcedureBuilderFactory,
+): ProcedureBuilder<TContext, TInput> => {
+  const create = factory ?? createProcedureBuilder;
+
+  const builder: ProcedureBuilder<TContext, TInput> = {
+    use: (middleware: any) => {
+      if (Array.isArray(middleware)) {
+        const combined: Middleware<any, any, any> = async ({
+          input,
+          ctx,
+          next,
+        }) => {
+          const results = await Promise.all(
+            middleware.map((mw) =>
+              mw({
+                input,
+                ctx,
+                next: <T>(opts: { ctx: T }) =>
+                  Promise.resolve({ result: undefined, ctx: opts.ctx }),
+              }),
+            ),
+          );
+          const mergedCtx = results.reduce(
+            // biome-ignore lint/performance/noAccumulatingSpread: idc
+            (acc, r) => ({ ...acc, ...r.ctx }),
+            ctx,
+          );
+          return next({ ctx: mergedCtx });
+        };
+        return create([...middlewares, { run: combined }], factory);
+      }
+
+      return create([...middlewares, { run: middleware }], factory);
+    },
+
+    input(schema: any) {
+      return create([createInputMiddleware(schema), ...middlewares], factory);
+    },
+
+    run(fn: any) {
+      return (async (input?: TInput) => {
+        const executeProcedure = async (
+          index: number,
+          ctx: unknown,
+        ): Promise<MiddlewareResult<any>> => {
+          if (index >= middlewares.length) {
+            return Promise.resolve(fn({ ctx, input })).then((result) => ({
+              result,
+              ctx,
+            }));
+          }
+
+          const mw = middlewares[index];
+          if (!mw) {
+            return Promise.resolve(fn({ ctx, input })).then((result) => ({
+              result,
+              ctx,
+            }));
+          }
+
+          return Promise.resolve(
+            mw.run({
+              input,
+              ctx,
+              next: <T>(opts: { ctx: T }) => {
+                return executeProcedure(index + 1, {
+                  ...(ctx ?? {}),
+                  ...opts.ctx,
+                }).then((result) => ({
+                  ...result,
+                  ctx: opts.ctx,
+                })) as Promise<MiddlewareResult<T>>;
+              },
+            }),
+          );
+        };
+
+        const { result } = await executeProcedure(0, undefined);
+        return result;
+      }) as any;
+    },
+  };
+
+  return builder;
+};
+
+function createInputMiddleware<TSchema extends StandardSchemaV1>(
+  schema: TSchema,
+) {
+  return createMiddleware("INPUT_VALIDATION", async (opts) => {
+    const result = await schema["~standard"].validate(opts.input);
+    if (result.issues) {
+      throw new Error("Input validation failed");
+    }
+    return opts.next({ ctx: opts.ctx });
+  });
+}
+
+export const createMiddleware = <TInput, TContext>(
+  id: string,
+  fn: Middleware<TInput, TContext, any>,
+): InternalMiddleware => ({
+  id,
+  run: fn,
+});

package/src/core.ts

@@ -0,0 +1,29 @@
+import {
+  createMiddleware,
+  createProcedureBuilder,
+  type Middleware,
+  type ProcedureBuilder,
+} from "./core-internal";
+import type { Awaitable } from "./types";
+
+export interface InitOptions<TContext> {
+  ctx: () => Awaitable<TContext>;
+}
+
+export interface ProcedureFactory<TContext> {
+  middleware: <TInput, TResult>(
+    fn: Middleware<TInput, TContext, TResult>,
+  ) => Middleware<TInput, TContext, TResult>;
+  procedure: ProcedureBuilder<TContext>;
+}
+
+export const init = <TContext>(
+  options: InitOptions<TContext>,
+): ProcedureFactory<TContext> => ({
+  middleware: (fn) => fn,
+  procedure: createProcedureBuilder([
+    createMiddleware("INITIAL_CONTEXT", async ({ next }) => {
+      return next({ ctx: await options.ctx() });
+    }),
+  ]),
+});

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./core";