ts-typed-api 0.1.9 → 0.1.11

package/dist/client-only.d.ts

@@ -1,3 +1,5 @@
 export { ApiClient, FetchHttpClientAdapter } from './client';
 export { CreateApiDefinition, CreateResponses } from './definition';
 export { z as ZodSchema } from 'zod';
+export type { ApiDefinitionSchema, RouteSchema, UnifiedError, InferDataFromUnifiedResponse, ApiClientParams, ApiClientQuery, ApiClientBody, ApiResponse, ApiBody, ApiParams, ApiQuery, FileType, HttpSuccessStatusCode, HttpClientErrorStatusCode, HttpServerErrorStatusCode, AllowedInputStatusCode, AllowedResponseStatusCode } from './definition';
+export type { HttpRequestOptions, HttpResponse, HttpClientAdapter, ApiCallResult, CallApiOptions } from './client';

package/dist/definition.js

@@ -48,32 +48,11 @@ exports.HttpServerErrorCodes = [500];
 function makeSchemaStrict(schema) {
     // Check if the schema has a .strict() method (ZodObject does)
     if ('strict' in schema && typeof schema.strict === 'function') {
-        //@ts-expect-error foobar
-        return makeStrict(schema);
-        // return schema.strict();
+        return schema.strict();
     }
     // For other schema types, return as-is
     return schema;
 }
-function makeStrict(schema) {
-    if (schema instanceof zod_1.z.ZodObject) {
-        const newShape = {};
-        for (const [key, subSchema] of Object.entries(schema.shape)) {
-            if (subSchema instanceof zod_1.z.ZodArray) {
-                const strictItemSchema = makeStrict(subSchema.element);
-                newShape[key] = zod_1.z.array(strictItemSchema);
-            }
-            else if (subSchema instanceof zod_1.z.ZodObject) {
-                newShape[key] = makeStrict(subSchema);
-            }
-            else {
-                newShape[key] = subSchema;
-            }
-        }
-        return zod_1.z.object(newShape).strict();
-    }
-    return schema;
-}
 // Helper function to create response schemas with unified structure and default 422 error
 // Schemas input is now constrained to use AllowedInputStatusCode as keys.
 function CreateResponses(schemas) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { ApiClient, FetchHttpClientAdapter } from './client';
-export { CreateApiDefinition, CreateResponses } from './definition';
-export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware } from './object-handlers';
+export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './definition';
+export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo } from './object-handlers';
 export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';

package/dist/object-handlers.d.ts

@@ -1,12 +1,13 @@
 import express from "express";
 import { ApiDefinitionSchema } from "./definition";
 import { TypedRequest, TypedResponse } from "./router";
-export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: {
+export type EndpointInfo<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = {
     [TDomain in keyof TDef['endpoints']]: {
         domain: TDomain;
         routeKey: keyof TDef['endpoints'][TDomain];
     };
-}[keyof TDef['endpoints']]) => void | Promise<void>;
+}[keyof TDef['endpoints']];
+export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: EndpointInfo<TDef>) => void | Promise<void>;
 export type SimpleMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction) => void | Promise<void>;
 export type UniversalEndpointMiddleware = (req: express.Request, res: express.Response, next: express.NextFunction, endpointInfo: {
     domain: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-typed-api",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "A lightweight, type-safe RPC library for TypeScript with Zod validation",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/client-only.ts

@@ -1,4 +1,33 @@
 // Client-only exports - no server dependencies
 export { ApiClient, FetchHttpClientAdapter } from './client';
 export { CreateApiDefinition, CreateResponses } from './definition';
-export { z as ZodSchema } from 'zod';
+export { z as ZodSchema } from 'zod';
+
+// Re-export types that are safe for client use
+export type {
+    ApiDefinitionSchema,
+    RouteSchema,
+    UnifiedError,
+    InferDataFromUnifiedResponse,
+    ApiClientParams,
+    ApiClientQuery,
+    ApiClientBody,
+    ApiResponse,
+    ApiBody,
+    ApiParams,
+    ApiQuery,
+    FileType,
+    HttpSuccessStatusCode,
+    HttpClientErrorStatusCode,
+    HttpServerErrorStatusCode,
+    AllowedInputStatusCode,
+    AllowedResponseStatusCode
+} from './definition';
+
+export type {
+    HttpRequestOptions,
+    HttpResponse,
+    HttpClientAdapter,
+    ApiCallResult,
+    CallApiOptions
+} from './client';

package/src/definition.ts

@@ -78,37 +78,12 @@ type CreateResponsesReturnType<InputSchemas extends Partial<Record<AllowedInputS
 function makeSchemaStrict(schema: ZodTypeAny): ZodTypeAny {
     // Check if the schema has a .strict() method (ZodObject does)
     if ('strict' in schema && typeof schema.strict === 'function') {
-        //@ts-expect-error foobar
-        return makeStrict(schema)
-        // return schema.strict();
+        return schema.strict();
     }
     // For other schema types, return as-is
     return schema;
 }
 
-function makeStrict<TSchema extends z.ZodType<any, any>>(
-    schema: TSchema extends z.ZodObject<any, any> ? TSchema : never
-): TSchema {
-    if (schema instanceof z.ZodObject) {
-        const newShape: { [key: string]: z.ZodType<any, any> } = {}
-
-        for (const [key, subSchema] of Object.entries(schema.shape)) {
-            if (subSchema instanceof z.ZodArray) {
-                const strictItemSchema = makeStrict(subSchema.element)
-                newShape[key] = z.array(strictItemSchema)
-            } else if (subSchema instanceof z.ZodObject) {
-                newShape[key] = makeStrict(subSchema)
-            } else {
-                newShape[key] = subSchema as any
-            }
-        }
-
-        return z.object(newShape).strict() as unknown as TSchema
-    }
-
-    return schema
-}
-
 // Helper function to create response schemas with unified structure and default 422 error
 // Schemas input is now constrained to use AllowedInputStatusCode as keys.
 export function CreateResponses<TInputMap extends Partial<Record<AllowedInputStatusCode, InputSchemaOrMarker>>>(

package/src/index.ts

@@ -1,5 +1,5 @@
 export { ApiClient, FetchHttpClientAdapter } from './client';
-export { CreateApiDefinition, CreateResponses } from './definition';
-export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware } from './object-handlers';
+export { CreateApiDefinition, CreateResponses, ApiDefinitionSchema } from './definition';
+export { RegisterHandlers, EndpointMiddleware, UniversalEndpointMiddleware, SimpleMiddleware, EndpointInfo } from './object-handlers';
 export { File as UploadedFile } from './router';
 export { z as ZodSchema } from 'zod';

package/src/object-handlers.ts

@@ -3,17 +3,19 @@ import { ApiDefinitionSchema } from "./definition";
 import { registerRouteHandlers, SpecificRouteHandler } from "./handler";
 import { TypedRequest, TypedResponse } from "./router";
 
+export type EndpointInfo<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = {
+    [TDomain in keyof TDef['endpoints']]: {
+        domain: TDomain;
+        routeKey: keyof TDef['endpoints'][TDomain];
+    }
+}[keyof TDef['endpoints']]
+
 // Type for middleware function that receives endpoint information
 export type EndpointMiddleware<TDef extends ApiDefinitionSchema = ApiDefinitionSchema> = (
     req: express.Request,
     res: express.Response,
     next: express.NextFunction,
-    endpointInfo: {
-        [TDomain in keyof TDef['endpoints']]: {
-            domain: TDomain;
-            routeKey: keyof TDef['endpoints'][TDomain];
-        }
-    }[keyof TDef['endpoints']]
+    endpointInfo: EndpointInfo<TDef>
 ) => void | Promise<void>;
 
 // Type for simple middleware that doesn't need endpoint information