@xrpckit/schema 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,130 @@
+import { ZodType, z } from 'zod';
+
+interface EndpointDefinition {
+    type: 'query' | 'mutation';
+    input: ZodType;
+    output: ZodType;
+}
+/**
+ * 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() }),
+ * });
+ * ```
+ */
+declare function query(config: {
+    input: ZodType;
+    output: ZodType;
+}): EndpointDefinition;
+/**
+ * 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() }),
+ * });
+ * ```
+ */
+declare function mutation(config: {
+    input: ZodType;
+    output: ZodType;
+}): EndpointDefinition;
+
+interface EndpointGroup {
+    [endpointName: string]: EndpointDefinition;
+}
+interface RouterDefinition {
+    [groupName: string]: EndpointGroup;
+}
+/**
+ * Get middleware associated with a router definition
+ * Used by parser to extract middleware metadata
+ */
+declare function getRouterMiddleware(router: RouterDefinition): Middleware[] | undefined;
+/**
+ * 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
+ */
+type Middleware<TContext = Record<string, unknown>> = (req: Request, context: TContext) => Promise<TContext | Response>;
+/**
+ * Router configuration with optional middleware
+ */
+interface RouterConfig {
+    middleware?: Middleware[];
+    [groupName: string]: EndpointGroup | Middleware[] | undefined;
+}
+/**
+ * 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() }),
+ *   }),
+ * });
+ * ```
+ */
+declare function createEndpoint<T extends EndpointGroup>(endpoints: T): T;
+/**
+ * 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({ ... })
+ * });
+ */
+declare function createRouter<T extends RouterConfig | RouterDefinition>(config: T): T extends RouterConfig ? Omit<T, 'middleware'> : T;
+
+/**
+ * Infer input type from an endpoint definition
+ * @example
+ * type CreateInput = InferInput<typeof router.todo.create>;
+ */
+type InferInput<T extends {
+    input: ZodType;
+}> = 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']>;
+
+export { type EndpointDefinition, type EndpointGroup, type InferInput, type InferOutput, type Middleware, type RouterConfig, type RouterDefinition, createEndpoint, createRouter, getRouterMiddleware, mutation, query };

package/dist/index.js

@@ -0,0 +1,45 @@
+// src/router.ts
+var routerMiddleware = /* @__PURE__ */ new WeakMap();
+function getRouterMiddleware(router) {
+  return routerMiddleware.get(router);
+}
+function isRouterConfig(value) {
+  return value && typeof value === "object" && "middleware" in value && Array.isArray(value.middleware);
+}
+function createEndpoint(endpoints) {
+  return endpoints;
+}
+function createRouter(config) {
+  if (isRouterConfig(config)) {
+    const { middleware, ...endpoints } = config;
+    const routerDef = endpoints;
+    if (middleware && middleware.length > 0) {
+      routerMiddleware.set(routerDef, middleware);
+    }
+    return routerDef;
+  }
+  return config;
+}
+
+// src/endpoint.ts
+function query(config) {
+  return {
+    type: "query",
+    input: config.input,
+    output: config.output
+  };
+}
+function mutation(config) {
+  return {
+    type: "mutation",
+    input: config.input,
+    output: config.output
+  };
+}
+export {
+  createEndpoint,
+  createRouter,
+  getRouterMiddleware,
+  mutation,
+  query
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@xrpckit/schema",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mwesox/xrpc.git",
+    "directory": "packages/schema"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean"
+  },
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}