@spfn/core 0.1.0-alpha.8 → 0.1.0-alpha.82

package/dist/types/index.d.ts

@@ -0,0 +1,121 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TSchema } from '@sinclair/typebox';
+
+/**
+ * Standard error response format
+ *
+ * Used by ErrorHandler middleware for all error responses.
+ * Compatible with ApiResponse pattern for consistent API responses.
+ */
+interface ErrorResponse {
+    success: false;
+    error: {
+        message: string;
+        type: string;
+        statusCode: number;
+        stack?: string;
+        details?: any;
+    };
+}
+/**
+ * Success response wrapper
+ */
+interface ApiSuccessResponse<T = any> {
+    success: true;
+    data: T;
+    meta?: {
+        timestamp?: string;
+        requestId?: string;
+        pagination?: {
+            page: number;
+            limit: number;
+            total: number;
+            totalPages: number;
+        };
+        [key: string]: any;
+    };
+}
+/**
+ * Error response type (alias for ErrorResponse)
+ */
+type ApiErrorResponse = ErrorResponse;
+/**
+ * Unified API response type
+ */
+type ApiResponse<T = any> = ApiSuccessResponse<T> | ApiErrorResponse;
+/**
+ * Creates a TypeBox schema for ApiSuccessResponse<T>
+ *
+ * @example
+ * ```ts
+ * const UserSchema = Type.Object({
+ *   id: Type.String(),
+ *   name: Type.String(),
+ * });
+ *
+ * const contract = {
+ *   response: ApiSuccessSchema(UserSchema),
+ * };
+ * ```
+ */
+declare function ApiSuccessSchema<T extends TSchema>(dataSchema: T): _sinclair_typebox.TObject<{
+    success: _sinclair_typebox.TLiteral<true>;
+    data: T;
+    meta: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        timestamp: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        requestId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        pagination: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            page: _sinclair_typebox.TNumber;
+            limit: _sinclair_typebox.TNumber;
+            total: _sinclair_typebox.TNumber;
+            totalPages: _sinclair_typebox.TNumber;
+        }>>;
+    }>>;
+}>;
+/**
+ * Creates a TypeBox schema for ApiErrorResponse
+ */
+declare function ApiErrorSchema(): _sinclair_typebox.TObject<{
+    success: _sinclair_typebox.TLiteral<false>;
+    error: _sinclair_typebox.TObject<{
+        message: _sinclair_typebox.TString;
+        type: _sinclair_typebox.TString;
+        statusCode: _sinclair_typebox.TNumber;
+        stack: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        details: _sinclair_typebox.TOptional<_sinclair_typebox.TAny>;
+    }>;
+}>;
+/**
+ * Creates a TypeBox schema for ApiSuccessResponse<T>
+ *
+ * Use this in your route contract's response field for standardized responses.
+ * Note: ContractClient throws ApiClientError on failure, so only success type is needed.
+ *
+ * @example
+ * ```ts
+ * const contract = {
+ *   method: 'GET',
+ *   path: '/users/:id',
+ *   response: ApiResponseSchema(Type.Object({
+ *     id: Type.String(),
+ *     name: Type.String(),
+ *   })),
+ * };
+ * ```
+ */
+declare function ApiResponseSchema<T extends TSchema>(dataSchema: T): _sinclair_typebox.TObject<{
+    success: _sinclair_typebox.TLiteral<true>;
+    data: T;
+    meta: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        timestamp: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        requestId: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+        pagination: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+            page: _sinclair_typebox.TNumber;
+            limit: _sinclair_typebox.TNumber;
+            total: _sinclair_typebox.TNumber;
+            totalPages: _sinclair_typebox.TNumber;
+        }>>;
+    }>>;
+}>;
+
+export { type ApiErrorResponse, ApiErrorSchema, type ApiResponse, ApiResponseSchema, type ApiSuccessResponse, ApiSuccessSchema, type ErrorResponse };

package/dist/types/index.js

@@ -0,0 +1,38 @@
+import { Type } from '@sinclair/typebox';
+
+// src/types/api-response.ts
+function ApiSuccessSchema(dataSchema) {
+  return Type.Object({
+    success: Type.Literal(true),
+    data: dataSchema,
+    meta: Type.Optional(Type.Object({
+      timestamp: Type.Optional(Type.String()),
+      requestId: Type.Optional(Type.String()),
+      pagination: Type.Optional(Type.Object({
+        page: Type.Number(),
+        limit: Type.Number(),
+        total: Type.Number(),
+        totalPages: Type.Number()
+      }))
+    }))
+  });
+}
+function ApiErrorSchema() {
+  return Type.Object({
+    success: Type.Literal(false),
+    error: Type.Object({
+      message: Type.String(),
+      type: Type.String(),
+      statusCode: Type.Number(),
+      stack: Type.Optional(Type.String()),
+      details: Type.Optional(Type.Any())
+    })
+  });
+}
+function ApiResponseSchema(dataSchema) {
+  return ApiSuccessSchema(dataSchema);
+}
+
+export { ApiErrorSchema, ApiResponseSchema, ApiSuccessSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/api-response.ts"],"names":[],"mappings":";;;AAiFO,SAAS,iBAAoC,UAAA,EACpD;AACI,EAAA,OAAO,KAAK,MAAA,CAAO;AAAA,IACf,OAAA,EAAS,IAAA,CAAK,OAAA,CAAQ,IAAI,CAAA;AAAA,IAC1B,IAAA,EAAM,UAAA;AAAA,IACN,IAAA,EAAM,IAAA,CAAK,QAAA,CAAS,IAAA,CAAK,MAAA,CAAO;AAAA,MAC5B,SAAA,EAAW,IAAA,CAAK,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA;AAAA,MACtC,SAAA,EAAW,IAAA,CAAK,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA;AAAA,MACtC,UAAA,EAAY,IAAA,CAAK,QAAA,CAAS,IAAA,CAAK,MAAA,CAAO;AAAA,QAClC,IAAA,EAAM,KAAK,MAAA,EAAO;AAAA,QAClB,KAAA,EAAO,KAAK,MAAA,EAAO;AAAA,QACnB,KAAA,EAAO,KAAK,MAAA,EAAO;AAAA,QACnB,UAAA,EAAY,KAAK,MAAA;AAAO,OAC3B,CAAC;AAAA,KACL,CAAC;AAAA,GACL,CAAA;AACL;AAKO,SAAS,cAAA,GAChB;AACI,EAAA,OAAO,KAAK,MAAA,CAAO;AAAA,IACf,OAAA,EAAS,IAAA,CAAK,OAAA,CAAQ,KAAK,CAAA;AAAA,IAC3B,KAAA,EAAO,KAAK,MAAA,CAAO;AAAA,MACf,OAAA,EAAS,KAAK,MAAA,EAAO;AAAA,MACrB,IAAA,EAAM,KAAK,MAAA,EAAO;AAAA,MAClB,UAAA,EAAY,KAAK,MAAA,EAAO;AAAA,MACxB,KAAA,EAAO,IAAA,CAAK,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA;AAAA,MAClC,OAAA,EAAS,IAAA,CAAK,QAAA,CAAS,IAAA,CAAK,KAAK;AAAA,KACpC;AAAA,GACJ,CAAA;AACL;AAoBO,SAAS,kBAAqC,UAAA,EACrD;AACI,EAAA,OAAO,iBAAiB,UAAU,CAAA;AACtC","file":"index.js","sourcesContent":["/**\n * Standard API Response Types & Schemas\n *\n * Pure TypeBox schemas and type definitions for API responses.\n * Can be used in both server and client code.\n */\n\nimport type { TSchema } from '@sinclair/typebox';\nimport { Type } from '@sinclair/typebox';\n\n// ============================================================================\n// Type Definitions\n// ============================================================================\n\n/**\n * Standard error response format\n *\n * Used by ErrorHandler middleware for all error responses.\n * Compatible with ApiResponse pattern for consistent API responses.\n */\nexport interface ErrorResponse\n{\n    success: false;\n    error: {\n        message: string;\n        type: string;\n        statusCode: number;\n        stack?: string;\n        details?: any;\n    };\n}\n\n/**\n * Success response wrapper\n */\nexport interface ApiSuccessResponse<T = any>\n{\n    success: true;\n    data: T;\n    meta?: {\n        timestamp?: string;\n        requestId?: string;\n        pagination?: {\n            page: number;\n            limit: number;\n            total: number;\n            totalPages: number;\n        };\n        [key: string]: any;\n    };\n}\n\n/**\n * Error response type (alias for ErrorResponse)\n */\nexport type ApiErrorResponse = ErrorResponse;\n\n/**\n * Unified API response type\n */\nexport type ApiResponse<T = any> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n// ============================================================================\n// TypeBox Schema Helpers\n// ============================================================================\n\n/**\n * Creates a TypeBox schema for ApiSuccessResponse<T>\n *\n * @example\n * ```ts\n * const UserSchema = Type.Object({\n *   id: Type.String(),\n *   name: Type.String(),\n * });\n *\n * const contract = {\n *   response: ApiSuccessSchema(UserSchema),\n * };\n * ```\n */\nexport function ApiSuccessSchema<T extends TSchema>(dataSchema: T)\n{\n    return Type.Object({\n        success: Type.Literal(true),\n        data: dataSchema,\n        meta: Type.Optional(Type.Object({\n            timestamp: Type.Optional(Type.String()),\n            requestId: Type.Optional(Type.String()),\n            pagination: Type.Optional(Type.Object({\n                page: Type.Number(),\n                limit: Type.Number(),\n                total: Type.Number(),\n                totalPages: Type.Number(),\n            })),\n        })),\n    });\n}\n\n/**\n * Creates a TypeBox schema for ApiErrorResponse\n */\nexport function ApiErrorSchema()\n{\n    return Type.Object({\n        success: Type.Literal(false),\n        error: Type.Object({\n            message: Type.String(),\n            type: Type.String(),\n            statusCode: Type.Number(),\n            stack: Type.Optional(Type.String()),\n            details: Type.Optional(Type.Any()),\n        }),\n    });\n}\n\n/**\n * Creates a TypeBox schema for ApiSuccessResponse<T>\n *\n * Use this in your route contract's response field for standardized responses.\n * Note: ContractClient throws ApiClientError on failure, so only success type is needed.\n *\n * @example\n * ```ts\n * const contract = {\n *   method: 'GET',\n *   path: '/users/:id',\n *   response: ApiResponseSchema(Type.Object({\n *     id: Type.String(),\n *     name: Type.String(),\n *   })),\n * };\n * ```\n */\nexport function ApiResponseSchema<T extends TSchema>(dataSchema: T)\n{\n    return ApiSuccessSchema(dataSchema);\n}\n"]}

package/dist/types-BXibIEyj.d.ts

@@ -0,0 +1,60 @@
+import { Context } from 'hono';
+import { ContentfulStatusCode } from 'hono/utils/http-status';
+import { TSchema, Static } from '@sinclair/typebox';
+import { ApiSuccessResponse } from './types/index.js';
+
+/**
+ * File-based Routing System Type Definitions
+ */
+type HeaderRecord = Record<string, string | string[]>;
+type RouteMeta = {
+    public?: boolean;
+    skipMiddlewares?: string[];
+    tags?: string[];
+    description?: string;
+    deprecated?: boolean;
+};
+/**
+ * Route Contract: TypeBox-based type-safe route definition
+ *
+ * Defines the shape of request/response for a route endpoint
+ */
+type RouteContract = {
+    method: HttpMethod;
+    path: string;
+    params?: TSchema;
+    query?: TSchema;
+    body?: TSchema;
+    response: TSchema;
+    meta?: RouteMeta;
+};
+/**
+ * Infer types from RouteContract
+ *
+ * Extracts TypeScript types from TypeBox schemas
+ */
+type InferContract<TContract extends RouteContract> = {
+    params: TContract['params'] extends TSchema ? Static<TContract['params']> : Record<string, never>;
+    query: TContract['query'] extends TSchema ? Static<TContract['query']> : Record<string, never>;
+    body: TContract['body'] extends TSchema ? Static<TContract['body']> : Record<string, never>;
+    response: TContract['response'] extends TSchema ? Static<TContract['response']> : unknown;
+};
+/**
+ * RouteContext: Route Handler Dedicated Context
+ *
+ * Generic version with contract-based type inference
+ */
+type RouteContext<TContract extends RouteContract = any> = {
+    params: InferContract<TContract>['params'];
+    query: InferContract<TContract>['query'];
+    data(): Promise<InferContract<TContract>['body']>;
+    json(data: InferContract<TContract>['response'], status?: ContentfulStatusCode, headers?: HeaderRecord): Response;
+    success<T>(data: T, meta?: ApiSuccessResponse<T>['meta'], status?: number): Response;
+    paginated<T>(data: T[], page: number, limit: number, total: number): Response;
+    raw: Context;
+};
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type RouteHandler<TContract extends RouteContract = any> = (c: RouteContext<TContract>) => Response | Promise<Response>;
+declare function isHttpMethod(value: unknown): value is HttpMethod;
+
+export { type HttpMethod as H, type InferContract as I, type RouteContext as R, type RouteContract as a, type RouteHandler as b, type HeaderRecord as c, type RouteMeta as d, isHttpMethod as i };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spfn/core",
-  "version": "0.1.0-alpha.8",
+  "version": "0.1.0-alpha.82",
   "description": "SPFN Framework Core - File-based routing, transactions, repository pattern",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,15 +31,50 @@
       "import": "./dist/server/index.js",
       "require": "./dist/server/index.js"
     },
-    "./scripts": {
-      "types": "./dist/scripts/index.d.ts",
-      "import": "./dist/scripts/index.js",
-      "require": "./dist/scripts/index.js"
+    "./errors": {
+      "types": "./dist/errors/index.d.ts",
+      "import": "./dist/errors/index.js",
+      "require": "./dist/errors/index.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware/index.d.ts",
+      "import": "./dist/middleware/index.js",
+      "require": "./dist/middleware/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "require": "./dist/types/index.js"
+    },
+    "./cache": {
+      "types": "./dist/cache/index.d.ts",
+      "import": "./dist/cache/index.js",
+      "require": "./dist/cache/index.js"
     },
     "./codegen": {
       "types": "./dist/codegen/index.d.ts",
       "import": "./dist/codegen/index.js",
       "require": "./dist/codegen/index.js"
+    },
+    "./env": {
+      "types": "./dist/env/index.d.ts",
+      "import": "./dist/env/index.js",
+      "require": "./dist/env/index.js"
+    },
+    "./logger": {
+      "types": "./dist/logger/index.d.ts",
+      "import": "./dist/logger/index.js",
+      "require": "./dist/logger/index.js"
+    },
+    "./generators": {
+      "types": "./dist/codegen/generators/index.d.ts",
+      "import": "./dist/codegen/generators/index.js",
+      "require": "./dist/codegen/generators/index.js"
+    },
+    "./codegen/generators": {
+      "types": "./dist/codegen/generators/index.d.ts",
+      "import": "./dist/codegen/generators/index.js",
+      "require": "./dist/codegen/generators/index.js"
     }
   },
   "keywords": [
@@ -86,21 +121,27 @@
     "chalk": "^5.6.2",
     "chokidar": "^4.0.3",
     "dotenv": "^17.2.3",
-    "drizzle-orm": "^0.44.6",
+    "drizzle-orm": "^0.44.7",
     "drizzle-typebox": "^0.1.0",
     "hono": "^4.9.0",
+    "jiti": "^2.6.1",
+    "micromatch": "^4.0.8",
     "pino": "^10.0.0",
     "postgres": "^3.4.0",
     "typescript": "^5.3.3",
     "zod": "^4.1.11"
   },
   "optionalDependencies": {
-    "ioredis": "^5.4.1"
+    "ioredis": "^5.4.1",
+    "pino-pretty": "^11.0.0"
   },
   "devDependencies": {
+    "@types/micromatch": "^4.0.9",
     "@types/node": "^20.11.0",
+    "@vitest/coverage-v8": "^4.0.6",
+    "drizzle-kit": "^0.31.5",
     "tsup": "^8.0.0",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.6"
   },
   "files": [
     "dist",
@@ -114,15 +155,24 @@
   },
   "scripts": {
     "build": "tsup",
-    "dev": "tsup --watch",
+    "dev": "tsup",
     "test": "vitest",
-    "test:codegen": "vitest run --config vitest.codegen.config.ts",
-    "test:db": "dotenv -e .env.test -- vitest src/tests/db",
-    "docker:test:up": "docker compose -f ../../docker-compose.test.yml up -d",
-    "docker:test:down": "docker compose -f ../../docker-compose.test.yml down",
-    "docker:test:logs": "docker compose -f ../../docker-compose.test.yml logs -f",
-    "type-check": "tsc --noEmit",
-    "generate:client": "node dist/scripts/generate-client.js",
-    "generate:client:watch": "node dist/scripts/generate-client.js --watch"
+    "test:unit": "vitest --config vitest.unit.config.ts",
+    "test:integration": "vitest --config vitest.integration.config.ts",
+    "test:coverage": "vitest run --config vitest.unit.config.ts --coverage",
+    "test:logger": "vitest src/logger",
+    "test:errors": "vitest src/errors",
+    "test:codegen": "vitest src/codegen",
+    "test:route": "vitest src/route",
+    "test:client": "vitest src/client",
+    "test:middleware": "vitest src/middleware",
+    "test:env": "vitest src/env",
+    "test:cache": "vitest src/cache --config vitest.integration.config.ts",
+    "test:db": "vitest src/db --config vitest.integration.config.ts",
+    "test:server": "vitest src/server --config vitest.integration.config.ts",
+    "docker:test:up": "docker compose -f docker-compose.test.yml up -d",
+    "docker:test:down": "docker compose -f docker-compose.test.yml down",
+    "docker:test:logs": "docker compose -f docker-compose.test.yml logs -f",
+    "type-check": "tsc --noEmit"
   }
 }

package/dist/auto-loader-C44TcLmM.d.ts

@@ -1,125 +0,0 @@
-import { Hono } from 'hono';
-
-/**
- * Extend Hono Context to support skipMiddlewares metadata
- */
-declare module 'hono' {
-    interface ContextVariableMap {
-        _skipMiddlewares?: string[];
-    }
-}
-/**
- * AutoRouteLoader: Simplified File-based Routing System
- *
- * ## Features
- * - 📁 Auto-discovery: Scans routes directory and auto-registers
- * - 🔄 Dynamic routes: [id] → :id, [...slug] → *
- * - 📊 Statistics: Route registration stats for dashboard
- * - 🏷️ Grouping: Natural grouping by directory structure
- *
- * ## Usage
- * ```typescript
- * const app = new Hono();
- * await loadRoutes(app);
- * ```
- */
-type RouteInfo = {
-    /** URL path (e.g., /users/:id) */
-    path: string;
-    /** File path relative to routes dir */
-    file: string;
-    /** Route metadata from export */
-    meta?: {
-        description?: string;
-        tags?: string[];
-        auth?: boolean;
-        [key: string]: unknown;
-    };
-    /** Priority (1=static, 2=dynamic, 3=catch-all) */
-    priority: number;
-};
-type RouteStats = {
-    total: number;
-    byPriority: {
-        static: number;
-        dynamic: number;
-        catchAll: number;
-    };
-    byTag: Record<string, number>;
-    routes: RouteInfo[];
-};
-declare class AutoRouteLoader {
-    private routesDir;
-    private routes;
-    private registeredRoutes;
-    private debug;
-    private readonly middlewares;
-    constructor(routesDir: string, debug?: boolean, middlewares?: Array<{
-        name: string;
-        handler: any;
-    }>);
-    /**
-     * Load all routes from directory
-     */
-    load(app: Hono): Promise<RouteStats>;
-    /**
-     * Get route statistics
-     */
-    getStats(): RouteStats;
-    /**
-     * Recursively scan directory for .ts files
-     */
-    private scanFiles;
-    /**
-     * Check if file is a valid route file
-     */
-    private isValidRouteFile;
-    /**
-     * Load and register a single route
-     * Returns true if successful, false if failed
-     */
-    private loadRoute;
-    /**
-     * Convert file path to URL path
-     *
-     * Examples:
-     * - users/index.ts → /users
-     * - users/[id].ts → /users/:id
-     * - posts/[...slug].ts → /posts/*
-     */
-    private fileToPath;
-    /**
-     * Calculate route priority
-     * 1 = static, 2 = dynamic, 3 = catch-all
-     */
-    private calculatePriority;
-    /**
-     * Normalize path for conflict detection
-     *
-     * Converts dynamic parameter names to generic placeholders:
-     * - /users/:id → /users/:param
-     * - /users/:userId → /users/:param (conflict!)
-     * - /posts/* → /posts/* (unchanged)
-     *
-     * This allows detection of routes with different param names
-     * that would match the same URL patterns.
-     */
-    private normalizePath;
-    /**
-     * Log statistics
-     */
-    private logStats;
-}
-/**
- * Load routes from default location (src/server/routes)
- */
-declare function loadRoutes(app: Hono, options?: {
-    routesDir?: string;
-    debug?: boolean;
-    middlewares?: Array<{
-        name: string;
-        handler: any;
-    }>;
-}): Promise<RouteStats>;
-
-export { AutoRouteLoader as A, type RouteInfo as R, type RouteStats as a, loadRoutes as l };

package/dist/bind-pssq1NRT.d.ts

@@ -1,34 +0,0 @@
-import { Context } from 'hono';
-import { R as RouteContract, c as RouteContext } from './types-SlzTr8ZO.js';
-
-/**
- * Contract-based Route Handler Wrapper
- *
- * Binds a contract to a route handler, providing automatic validation
- * and type-safe context creation.
- *
- * ## Features
- * - ✅ Automatic params/query/body validation using TypeBox
- * - ✅ Type-safe RouteContext with contract-based inference
- * - ✅ Clean separation: bind() for validation, Hono for middleware
- *
- * ## Usage
- *
- * ```typescript
- * // Basic usage
- * export const GET = bind(contract, async (c) => {
- *     return c.json({ data: 'public' });
- * });
- *
- * // For middleware, use Hono's app-level or route-level middleware:
- * // app.use('/api/*', authMiddleware);
- * // app.get('/users/:id', authMiddleware, bind(contract, handler));
- * ```
- *
- * @param contract - Route contract defining params, query, body, response schemas
- * @param handler - Route handler function
- * @returns Hono-compatible handler function
- */
-declare function bind<TContract extends RouteContract>(contract: TContract, handler: (c: RouteContext<TContract>) => Response | Promise<Response>): (rawContext: Context) => Promise<Response>;
-
-export { bind as b };