@codexsploitx/schemaapi 1.0.4 → 1.0.6

package/bin/schemaapi

@@ -23,6 +23,14 @@ function showHelp() {
   console.log("  schemaapi generate tests");
   console.log("  schemaapi audit");
   console.log("  schemaapi init <adapter>");
+  console.log("");
+  console.log("Adapters:");
+  console.log("  express");
+  console.log("  next");
+  console.log("  fastify");
+  console.log("  remix");
+  console.log("  nest");
+  console.log("  deno");
 }
 
 function loadConfig() {
@@ -228,7 +236,7 @@ function handleInit(adapterArg) {
   const usersContractPath = path.join(contractsDir, "usersContract.ts");
   if (!fs.existsSync(usersContractPath)) {
     const usersContractContent = [
-      'import { createContract } from "schemaapi";',
+      'import { createContract } from "@codexsploitx/schemaapi";',
       'import { z } from "zod";',
       "",
       "export const usersContract = createContract({",
@@ -257,7 +265,7 @@ function handleInit(adapterArg) {
     const routePath = path.join(appApiUsersDir, "route.ts");
     if (!fs.existsSync(routePath)) {
       const nextRouteContent = [
-        'import { adapters } from "schemaapi";',
+        'import { adapters } from "@codexsploitx/schemaapi";',
         'import { usersContract } from "../../../contracts";',
         "",
         "const handlers = adapters.next.handleContract(usersContract, {",

package/dist/adapters/deno.d.ts

@@ -0,0 +1,4 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+export declare function handleContract(contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>): (req: Request) => Promise<Response>;
+export {};

package/dist/adapters/express.d.ts

@@ -0,0 +1,21 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+export interface ExpressLikeRequest {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+    headers: Record<string, string>;
+    user?: unknown;
+    [key: string]: unknown;
+}
+export interface ExpressLikeResponse {
+    json: (body: unknown) => void;
+    send?: (body: unknown) => void;
+    setHeader?: (name: string, value: string) => void;
+}
+export type ExpressLikeHandler = (req: ExpressLikeRequest, res: ExpressLikeResponse, next: (err?: unknown) => void) => void | Promise<void>;
+export type ExpressLikeApp = {
+    [method: string]: (path: string, handler: ExpressLikeHandler) => void;
+};
+export declare function handleContract(app: ExpressLikeApp, contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>): void;
+export {};

package/dist/adapters/fastify.d.ts

@@ -0,0 +1,23 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+interface FastifyLikeRequest {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+    headers: Record<string, string>;
+    user?: unknown;
+}
+interface FastifyLikeReply {
+    status: (code: number) => FastifyLikeReply;
+    send: (payload: unknown) => void;
+    header: (key: string, value: string) => FastifyLikeReply;
+}
+interface FastifyInstance {
+    route: (options: {
+        method: string | string[];
+        url: string;
+        handler: (request: FastifyLikeRequest, reply: FastifyLikeReply) => Promise<void> | void;
+    }) => void;
+}
+export declare function handleContract(fastify: FastifyInstance, contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>): void;
+export {};

package/dist/adapters/hapi.d.ts

@@ -0,0 +1,28 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+interface HapiLikeRequest {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    payload: unknown;
+    headers: Record<string, string>;
+    auth?: {
+        credentials?: unknown;
+    };
+}
+interface HapiLikeResponseObject {
+    type: (contentType: string) => void;
+    header: (key: string, value: string) => void;
+    code: (statusCode: number) => void;
+}
+interface HapiLikeResponseToolkit {
+    response: (data: unknown) => HapiLikeResponseObject;
+}
+interface HapiServer {
+    route: (options: {
+        method: string;
+        path: string;
+        handler: (request: HapiLikeRequest, h: HapiLikeResponseToolkit) => Promise<unknown> | unknown;
+    }) => void;
+}
+export declare function handleContract(server: HapiServer, contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>): void;
+export {};

package/dist/adapters/index.d.ts

@@ -0,0 +1,9 @@
+export * as express from "./express";
+export * as next from "./next";
+export * as fastify from "./fastify";
+export * as nest from "./nest";
+export * as koa from "./koa";
+export * as hapi from "./hapi";
+export * as remix from "./remix";
+export * as deno from "./deno";
+export * as ws from "./ws";

package/dist/adapters/koa.d.ts

@@ -0,0 +1,22 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+interface KoaLikeContext {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    request: {
+        body?: unknown;
+    };
+    headers: Record<string, string>;
+    state?: {
+        user?: unknown;
+    };
+    body?: unknown;
+    type?: string;
+    set: (key: string, value: string) => void;
+    status?: number;
+}
+interface KoaRouter {
+    register: (path: string, methods: string[], middleware: (ctx: KoaLikeContext, next: () => Promise<unknown>) => Promise<unknown>) => void;
+}
+export declare function handleContract(router: KoaRouter, contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>): void;
+export {};

package/dist/adapters/nest.d.ts

@@ -0,0 +1,35 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+interface NestLikeRequest {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+    headers: Record<string, string>;
+    user?: unknown;
+}
+interface NestLikeResponse {
+    send?: (payload: unknown) => void;
+    json?: (payload: unknown) => void;
+    end: (payload: string) => void;
+    status?: (code: number) => void;
+    code?: (code: number) => void;
+}
+type HttpMethodHandler = (path: string, handler: (req: NestLikeRequest, res: NestLikeResponse, next: unknown) => Promise<void>) => void;
+interface NestApp {
+    getHttpAdapter: () => {
+        getInstance: () => unknown;
+        getRequestMethod: (request: unknown) => string;
+        getRequestUrl: (request: unknown) => string;
+        createMiddlewareFactory: (method: unknown) => unknown;
+        get: HttpMethodHandler;
+        post: HttpMethodHandler;
+        put: HttpMethodHandler;
+        delete: HttpMethodHandler;
+        patch: HttpMethodHandler;
+        [key: string]: unknown;
+    };
+}
+export declare const SchemaApiModule: {
+    register(app: NestApp, contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>): void;
+};
+export {};

package/dist/adapters/next.d.ts

@@ -0,0 +1,30 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+interface NextRequest {
+    nextUrl: {
+        searchParams: URLSearchParams;
+        pathname: string;
+    };
+    json: () => Promise<unknown>;
+    headers: Headers;
+    method: string;
+    url: string;
+}
+export declare function handleContract(contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>): {
+    GET: (req: Request | NextRequest, { params }: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+    POST: (req: Request | NextRequest, { params }: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+    PUT: (req: Request | NextRequest, { params }: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+    DELETE: (req: Request | NextRequest, { params }: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+    PATCH: (req: Request | NextRequest, { params }: {
+        params?: Record<string, string>;
+    }) => Promise<Response>;
+};
+export {};

package/dist/adapters/remix.d.ts

@@ -0,0 +1,14 @@
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+type RemixParams = Record<string, string | undefined>;
+export declare function createRouteHandlers(contract: AnyContract, handlers: Record<string, (ctx: Record<string, unknown>) => unknown | Promise<unknown>>, routePattern: string): {
+    loader: (args: {
+        request: Request;
+        params: RemixParams;
+    }) => Promise<Response>;
+    action: (args: {
+        request: Request;
+        params: RemixParams;
+    }) => Promise<Response>;
+};
+export {};

package/dist/adapters/ws.d.ts

@@ -0,0 +1,14 @@
+import { WebSocketServer, WebSocket } from "ws";
+import type { IncomingMessage } from "http";
+import type { createContract } from "../core/contract";
+type AnyContract = ReturnType<typeof createContract>;
+type WsHandlerContext = {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    headers: IncomingMessage["headers"];
+    ws: WebSocket;
+    send: (data: unknown) => void;
+    onMessage: (cb: (data: unknown) => void) => void;
+};
+export declare function handleContract(wss: WebSocketServer, contract: AnyContract, handlers: Record<string, (ctx: WsHandlerContext) => void | Promise<void>>): WebSocketServer;
+export {};

package/dist/core/client.d.ts

@@ -0,0 +1,16 @@
+type WebSocketLike = {
+    close: (code?: number, reason?: string) => void;
+};
+type WebSocketConstructor = new (url: string) => WebSocketLike;
+type ClientConfig = {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    WebSocket?: WebSocketConstructor;
+};
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export type ExtractSchema<TContract> = TContract;
+export type InferResponse<TContract, Endpoint extends string> = unknown;
+export declare function createClient<T>(contract: {
+    schema: T;
+}, config: ClientConfig): Record<string, unknown>;
+export {};

package/dist/core/contract.d.ts

@@ -1,4 +1,75 @@
-export declare function createContract(schema: any): {
-    handle(endpoint: string, handler: Function): Function;
-    schema: any;
+import { ZodTypeAny } from "zod";
+export declare class SchemaApiError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+}
+type RequestContext = {
+    params?: unknown;
+    query?: unknown;
+    body?: unknown;
+    headers?: unknown;
+    user?: {
+        role?: string;
+    };
+    [key: string]: unknown;
 };
+type MediaConfig = {
+    kind?: "upload" | "download";
+    contentTypes?: string[];
+    maxSize?: number;
+};
+export type NormalizedErrorPayload = {
+    error: string;
+    message: string;
+    status: number;
+};
+export declare function buildErrorPayload(error: unknown): NormalizedErrorPayload;
+type MethodDefinition = {
+    params?: ZodTypeAny;
+    query?: ZodTypeAny;
+    body?: ZodTypeAny;
+    headers?: ZodTypeAny;
+    roles?: string[];
+    response?: ZodTypeAny;
+    clientMessages?: ZodTypeAny;
+    serverMessages?: ZodTypeAny;
+    media?: MediaConfig;
+    errors?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type RouteDefinition = Record<string, MethodDefinition>;
+type ContractDefinition = Record<string, RouteDefinition>;
+type CompareResult = {
+    breakingChanges: string[];
+};
+export type FieldDoc = {
+    name: string;
+    type?: string;
+    optional: boolean;
+};
+export type MethodDoc = {
+    method: string;
+    path: string;
+    params?: FieldDoc[];
+    query?: FieldDoc[];
+    body?: FieldDoc[];
+    headers?: FieldDoc[];
+    roles?: string[];
+    errors?: {
+        status: string;
+        code: string;
+    }[];
+    media?: MediaConfig;
+};
+export type ContractDocs = {
+    routes: MethodDoc[];
+};
+export declare function createContract<T extends ContractDefinition>(schema: T): {
+    handle(endpoint: string, handler: (ctx: RequestContext) => unknown | Promise<unknown>): (ctx: RequestContext) => Promise<unknown>;
+    compareWith(other: {
+        schema: ContractDefinition;
+    }): CompareResult;
+    docs(): ContractDocs;
+    schema: T;
+};
+export {};

package/dist/core/versioning.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/docs.d.ts

@@ -0,0 +1,12 @@
+import type { ContractDocs } from "./core/contract";
+export type DocsFormat = "json" | "html" | "text";
+export type RenderHtmlOptions = {
+    title?: string;
+    theme?: "light" | "dark" | "auto";
+};
+export declare function renderDocsJSON(docs: ContractDocs): string;
+export declare function renderDocsText(docs: ContractDocs): string;
+export declare function renderDocsHTML(docs: ContractDocs, options?: RenderHtmlOptions): string;
+export declare function renderDocs(docs: ContractDocs, options: {
+    format: DocsFormat;
+} & Partial<RenderHtmlOptions>): string;

package/dist/index.d.ts

@@ -1 +1,5 @@
 export * from "./core/contract";
+export * from "./core/client";
+export { generateSDK } from "./sdk";
+export * as adapters from "./adapters";
+export * from "./docs";

package/dist/playground.d.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export declare const contract: {
+    handle(endpoint: string, handler: (ctx: {
+        [key: string]: unknown;
+        params?: unknown;
+        query?: unknown;
+        body?: unknown;
+        headers?: unknown;
+        user?: {
+            role?: string;
+        };
+    }) => unknown | Promise<unknown>): (ctx: {
+        [key: string]: unknown;
+        params?: unknown;
+        query?: unknown;
+        body?: unknown;
+        headers?: unknown;
+        user?: {
+            role?: string;
+        };
+    }) => Promise<unknown>;
+    compareWith(other: {
+        schema: {
+            [x: string]: {
+                [x: string]: {
+                    [key: string]: unknown;
+                    params?: z.ZodType;
+                    query?: z.ZodType;
+                    body?: z.ZodType;
+                    headers?: z.ZodType;
+                    roles?: string[];
+                    response?: z.ZodType;
+                    clientMessages?: z.ZodType;
+                    serverMessages?: z.ZodType;
+                    media?: {
+                        kind?: "upload" | "download";
+                        contentTypes?: string[];
+                        maxSize?: number;
+                    };
+                    errors?: Record<string, unknown>;
+                };
+            };
+        };
+    }): {
+        breakingChanges: string[];
+    };
+    docs(): import("./index").ContractDocs;
+    schema: {
+        "/users/:id": {
+            GET: {
+                params: z.ZodObject<{
+                    id: z.ZodString;
+                }, z.core.$strip>;
+                headers: z.ZodObject<{
+                    authorization: z.ZodString;
+                }, z.core.$strip>;
+                roles: string[];
+                response: z.ZodObject<{
+                    id: z.ZodString;
+                    username: z.ZodString;
+                }, z.core.$strip>;
+            };
+        };
+    };
+};

package/dist/playground.test.d.ts

@@ -0,0 +1 @@
+export {};