xrpckit 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { ZodType, z } from 'zod';
+import { z } from 'zod';
 
-interface EndpointDefinition {
-    type: 'query' | 'mutation';
-    input: ZodType;
-    output: ZodType;
+interface EndpointDefinition<TInputSchema extends z.ZodTypeAny = z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny = z.ZodTypeAny> {
+    type: "query" | "mutation";
+    input: TInputSchema;
+    output: TOutputSchema;
 }
 /**
  * Creates a query endpoint definition.
@@ -22,10 +22,10 @@ interface EndpointDefinition {
  * });
  * ```
  */
-declare function query(config: {
-    input: ZodType;
-    output: ZodType;
-}): EndpointDefinition;
+declare function query<TInputSchema extends z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny>(config: {
+    input: TInputSchema;
+    output: TOutputSchema;
+}): EndpointDefinition<TInputSchema, TOutputSchema>;
 /**
  * Creates a mutation endpoint definition.
  * Mutations are typically used for write operations that modify server state.
@@ -43,13 +43,13 @@ declare function query(config: {
  * });
  * ```
  */
-declare function mutation(config: {
-    input: ZodType;
-    output: ZodType;
-}): EndpointDefinition;
+declare function mutation<TInputSchema extends z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny>(config: {
+    input: TInputSchema;
+    output: TOutputSchema;
+}): EndpointDefinition<TInputSchema, TOutputSchema>;
 
 interface EndpointGroup {
-    [endpointName: string]: EndpointDefinition;
+    [endpointName: string]: EndpointDefinition<z.ZodTypeAny, z.ZodTypeAny>;
 }
 interface RouterDefinition {
     [groupName: string]: EndpointGroup;
@@ -108,7 +108,7 @@ declare function createEndpoint<T extends EndpointGroup>(endpoints: T): T;
  *   greeting: createEndpoint({ ... })
  * });
  */
-declare function createRouter<T extends RouterConfig | RouterDefinition>(config: T): T extends RouterConfig ? Omit<T, 'middleware'> : T;
+declare function createRouter<T extends RouterConfig | RouterDefinition>(config: T): T extends RouterConfig ? Omit<T, "middleware"> : T;
 
 /**
  * Infer input type from an endpoint definition
@@ -116,15 +116,15 @@ declare function createRouter<T extends RouterConfig | RouterDefinition>(config:
  * type CreateInput = InferInput<typeof router.todo.create>;
  */
 type InferInput<T extends {
-    input: ZodType;
-}> = z.infer<T['input']>;
+    input: z.ZodTypeAny;
+}> = z.infer<T["input"]>;
 /**
  * Infer output type from an endpoint definition
  * @example
  * type CreateOutput = InferOutput<typeof router.todo.create>;
  */
 type InferOutput<T extends {
-    output: ZodType;
-}> = z.infer<T['output']>;
+    output: z.ZodTypeAny;
+}> = z.infer<T["output"]>;
 
 export { type EndpointDefinition, type EndpointGroup, type InferInput, type InferOutput, type Middleware, type RouterConfig, type RouterDefinition, createEndpoint, createRouter, getRouterMiddleware, mutation, query };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xrpckit",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Type-safe, cross-platform RPC framework - define API contracts with Zod schemas",
   "type": "module",
   "license": "MIT",
@@ -28,10 +28,13 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean"
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "prepublishOnly": "npm run build",
+    "release": "npm publish --//registry.npmjs.org/:_authToken=$NPM_XRPC_APIKEY"
   },
   "dependencies": {
     "zod": "^4.0.0"

package/src/endpoint.ts

@@ -0,0 +1,72 @@
+import type { z } from "zod";
+
+export interface EndpointDefinition<
+  TInputSchema extends z.ZodTypeAny = z.ZodTypeAny,
+  TOutputSchema extends z.ZodTypeAny = z.ZodTypeAny,
+> {
+  type: "query" | "mutation";
+  input: TInputSchema;
+  output: TOutputSchema;
+}
+
+/**
+ * Creates a query endpoint definition.
+ * Queries are typically used for read operations that don't modify server state.
+ *
+ * @param config - Configuration object containing input and output Zod schemas
+ * @param config.input - Zod schema for validating the input parameters
+ * @param config.output - Zod schema for validating the output response
+ * @returns An endpoint definition with type 'query'
+ *
+ * @example
+ * ```typescript
+ * const getUser = query({
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ * });
+ * ```
+ */
+export function query<
+  TInputSchema extends z.ZodTypeAny,
+  TOutputSchema extends z.ZodTypeAny,
+>(config: {
+  input: TInputSchema;
+  output: TOutputSchema;
+}): EndpointDefinition<TInputSchema, TOutputSchema> {
+  return {
+    type: "query",
+    input: config.input,
+    output: config.output,
+  };
+}
+
+/**
+ * Creates a mutation endpoint definition.
+ * Mutations are typically used for write operations that modify server state.
+ *
+ * @param config - Configuration object containing input and output Zod schemas
+ * @param config.input - Zod schema for validating the input parameters
+ * @param config.output - Zod schema for validating the output response
+ * @returns An endpoint definition with type 'mutation'
+ *
+ * @example
+ * ```typescript
+ * const createUser = mutation({
+ *   input: z.object({ name: z.string(), email: z.string().email() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ * });
+ * ```
+ */
+export function mutation<
+  TInputSchema extends z.ZodTypeAny,
+  TOutputSchema extends z.ZodTypeAny,
+>(config: {
+  input: TInputSchema;
+  output: TOutputSchema;
+}): EndpointDefinition<TInputSchema, TOutputSchema> {
+  return {
+    type: "mutation",
+    input: config.input,
+    output: config.output,
+  };
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export {
+  createRouter,
+  createEndpoint,
+  getRouterMiddleware,
+  type RouterDefinition,
+  type EndpointGroup,
+  type Middleware,
+  type RouterConfig,
+} from "./router";
+export { query, mutation, type EndpointDefinition } from "./endpoint";
+export type { InferInput, InferOutput } from "./types";

package/src/router.ts

@@ -0,0 +1,113 @@
+import type { z } from "zod";
+import type { EndpointDefinition } from "./endpoint";
+
+export interface EndpointGroup {
+  [endpointName: string]: EndpointDefinition<z.ZodTypeAny, z.ZodTypeAny>;
+}
+
+export interface RouterDefinition {
+  [groupName: string]: EndpointGroup;
+}
+
+// WeakMap to store middleware separately from router definition
+const routerMiddleware = new WeakMap<RouterDefinition, Middleware[]>();
+
+/**
+ * Get middleware associated with a router definition
+ * Used by parser to extract middleware metadata
+ */
+export function getRouterMiddleware(
+  router: RouterDefinition,
+): Middleware[] | undefined {
+  return routerMiddleware.get(router);
+}
+
+/**
+ * Middleware function type for extending context
+ * Middleware receives the request and current context, and returns updated context
+ * Note: In generated code, middleware is implemented per-target (Go, TypeScript, etc.)
+ * This type is for documentation and type checking in the contract definition
+ */
+export type Middleware<TContext = Record<string, unknown>> = (
+  req: Request,
+  context: TContext,
+) => Promise<TContext | Response>;
+
+/**
+ * Router configuration with optional middleware
+ */
+export interface RouterConfig {
+  middleware?: Middleware[];
+  [groupName: string]: EndpointGroup | Middleware[] | undefined;
+}
+
+/**
+ * Type guard to check if a value is a RouterConfig
+ */
+function isRouterConfig(
+  value: RouterDefinition | RouterConfig,
+): value is RouterConfig {
+  return (
+    value &&
+    typeof value === "object" &&
+    "middleware" in value &&
+    Array.isArray(value.middleware)
+  );
+}
+
+/**
+ * Creates an endpoint group containing one or more endpoints.
+ *
+ * @param endpoints - An object mapping endpoint names to their definitions (query or mutation)
+ * @returns The endpoint group with preserved types
+ *
+ * @example
+ * ```typescript
+ * const greeting = createEndpoint({
+ *   greet: query({
+ *     input: z.object({ name: z.string() }),
+ *     output: z.object({ message: z.string() }),
+ *   }),
+ * });
+ * ```
+ */
+export function createEndpoint<T extends EndpointGroup>(endpoints: T): T {
+  return endpoints;
+}
+
+/**
+ * Creates a router with optional middleware support
+ *
+ * @example
+ * // Without middleware
+ * const router = createRouter({
+ *   greeting: createEndpoint({ ... })
+ * });
+ *
+ * @example
+ * // With middleware
+ * const router = createRouter({
+ *   middleware: [
+ *     async (req, ctx) => ({ ...ctx, userId: extractUserId(req) })
+ *   ],
+ *   greeting: createEndpoint({ ... })
+ * });
+ */
+export function createRouter<T extends RouterConfig | RouterDefinition>(
+  config: T,
+): T extends RouterConfig ? Omit<T, "middleware"> : T {
+  // If it's a RouterConfig with middleware, extract the endpoints
+  if (isRouterConfig(config)) {
+    const { middleware, ...endpoints } = config;
+    const routerDef = endpoints as RouterDefinition;
+
+    // Store middleware in WeakMap instead of property
+    if (middleware && middleware.length > 0) {
+      routerMiddleware.set(routerDef, middleware);
+    }
+    return routerDef as T extends RouterConfig ? Omit<T, "middleware"> : T;
+  }
+
+  // Otherwise, it's a plain RouterDefinition
+  return config as T extends RouterConfig ? Omit<T, "middleware"> : T;
+}

package/src/types.ts

@@ -0,0 +1,17 @@
+import type { z } from "zod";
+
+/**
+ * Infer input type from an endpoint definition
+ * @example
+ * type CreateInput = InferInput<typeof router.todo.create>;
+ */
+export type InferInput<T extends { input: z.ZodTypeAny }> = z.infer<T["input"]>;
+
+/**
+ * Infer output type from an endpoint definition
+ * @example
+ * type CreateOutput = InferOutput<typeof router.todo.create>;
+ */
+export type InferOutput<T extends { output: z.ZodTypeAny }> = z.infer<
+  T["output"]
+>;