lacis 0.2.0

package/dist/index.js

@@ -0,0 +1,457 @@
+import { router, loadRoutes, primaryLog, getAdapter } from './chunk-NVNSYLVY.js';
+export { addMiddleware, addPathMiddleware, collectMiddleware, createCorsMiddleware, createSSEClient, findRoute, getPathMiddlewares, getRouterStats, getRoutesDir, hasMiddlewares, initSSE, isRouteError, loadMiddlewares, loadRoutes, registerCorsConfig, registerMiddlewareConfig, registerRoutes, resetMiddlewares, resetRouter, router, runMiddlewares, send, sendEvent, sendJson, setVerboseLogging, sseClose, sseComment, sseEventError, sseId, sseRetry } from './chunk-NVNSYLVY.js';
+import cluster from 'cluster';
+
+// src/config/serverConfig.ts
+var defaultConfig = {
+  port: 3e3,
+  isDev: process.env.NODE_ENV === "development",
+  timeout: 3e4,
+  cluster: {
+    enabled: true,
+    workers: void 0
+  },
+  platform: "node"
+};
+function getConfig(customConfig = {}) {
+  return {
+    ...defaultConfig,
+    ...customConfig
+  };
+}
+
+// src/core/defineHandler.ts
+async function runValidation(schema, value) {
+  const result = await schema["~standard"].validate(value);
+  if (result.issues) return { success: false, issues: result.issues };
+  return { success: true, data: result.value };
+}
+function formatIssues(issues) {
+  return Array.from(issues).map((issue) => ({
+    message: issue.message,
+    path: issue.path ? Array.from(issue.path).map((p) => typeof p === "object" && "key" in p ? p.key : p) : void 0
+  }));
+}
+function defineHandler(config) {
+  const wrapped = async (req, res) => {
+    if (config.params) {
+      const result = await runValidation(config.params, req.params ?? {});
+      if (!result.success) {
+        res.status(400).json({ error: "Validation failed", issues: formatIssues(result.issues) });
+        return;
+      }
+      req.params = result.data;
+    }
+    if (config.query) {
+      const result = await runValidation(config.query, req.query ?? {});
+      if (!result.success) {
+        res.status(400).json({ error: "Validation failed", issues: formatIssues(result.issues) });
+        return;
+      }
+      req.query = result.data;
+    }
+    if (config.body) {
+      let rawBody;
+      try {
+        rawBody = await req.json();
+      } catch {
+        res.status(400).json({ error: "Invalid JSON body" });
+        return;
+      }
+      const result = await runValidation(config.body, rawBody);
+      if (!result.success) {
+        res.status(400).json({ error: "Validation failed", issues: formatIssues(result.issues) });
+        return;
+      }
+      req.body = result.data;
+    }
+    await config.handler(req, res);
+  };
+  wrapped._defineHandler = config;
+  return wrapped;
+}
+
+// src/core/openapi.ts
+async function schemaToJsonSchema(schema) {
+  const vendor = schema?.["~standard"]?.vendor;
+  if (!vendor) return null;
+  try {
+    if (vendor === "zod") {
+      const zod = await import('zod');
+      if (typeof zod.toJSONSchema === "function") return zod.toJSONSchema(schema);
+      const mod = await import('zod-to-json-schema');
+      return (mod.zodToJsonSchema ?? mod.default)(schema, { target: "openApi3" });
+    }
+    if (vendor === "valibot") {
+      const mod = await import('@valibot/to-json-schema');
+      return (mod.toJsonSchema ?? mod.default)(schema);
+    }
+    if (vendor === "arktype") {
+      return schema.toJsonSchema();
+    }
+  } catch {
+    primaryLog(`[openapi] no converter found for "${vendor}" \u2014 install the matching json-schema package`);
+  }
+  return null;
+}
+function toOpenApiPath(path) {
+  return path.replace(/:(\w+)\??/g, "{$1}");
+}
+async function buildOperation(method, config) {
+  const op = {
+    responses: { "200": { description: "Success" } }
+  };
+  if (config.meta?.summary) op.summary = config.meta.summary;
+  if (config.meta?.description) op.description = config.meta.description;
+  if (config.meta?.tags) op.tags = config.meta.tags;
+  if (config.meta?.deprecated) op.deprecated = config.meta.deprecated;
+  const parameters = [];
+  if (config.params) {
+    const jsonSchema = await schemaToJsonSchema(config.params);
+    if (jsonSchema?.properties) {
+      for (const [name, propSchema] of Object.entries(jsonSchema.properties)) {
+        parameters.push({ name, in: "path", required: true, schema: propSchema });
+      }
+    }
+  }
+  if (config.query) {
+    const jsonSchema = await schemaToJsonSchema(config.query);
+    if (jsonSchema?.properties) {
+      const required = jsonSchema.required ?? [];
+      for (const [name, propSchema] of Object.entries(jsonSchema.properties)) {
+        parameters.push({ name, in: "query", required: required.includes(name), schema: propSchema });
+      }
+    }
+  }
+  if (parameters.length > 0) op.parameters = parameters;
+  if (config.body) {
+    const jsonSchema = await schemaToJsonSchema(config.body);
+    if (jsonSchema) {
+      op.requestBody = {
+        required: true,
+        content: { "application/json": { schema: jsonSchema } }
+      };
+    }
+  }
+  return op;
+}
+async function buildOpenApiDoc(config) {
+  const routes = router.getRoutes();
+  const paths = {};
+  for (const { method, path, handler } of routes) {
+    const defineConfig = handler._defineHandler;
+    const openApiPath = toOpenApiPath(path);
+    if (!paths[openApiPath]) paths[openApiPath] = {};
+    paths[openApiPath][method.toLowerCase()] = defineConfig ? await buildOperation(method, defineConfig) : { responses: { "200": { description: "Success" } } };
+  }
+  return { openapi: "3.1.0", info: config.info, paths };
+}
+var serverInstance = null;
+var isShuttingDown = false;
+var shutdownListenersRegistered = false;
+async function createServer(routesDir, config = defaultConfig) {
+  const { platform = "node" } = config;
+  const verbose = config.isDev && cluster.isPrimary && !process.env.ZENO_BUN_WORKER;
+  try {
+    await loadRoutes(routesDir);
+    if (config.openapi) {
+      const doc = await buildOpenApiDoc(config.openapi);
+      const openapiPath = config.openapi.path ?? "/openapi.json";
+      router.addRoute("GET", openapiPath, (_req, res) => res.json(doc));
+      if (verbose) primaryLog(`OpenAPI doc available at ${openapiPath}`);
+    }
+    if (verbose) {
+      primaryLog("\u{1F680} Serveur d\xE9marr\xE9");
+      primaryLog(`\u{1F4C2} Routes charg\xE9es depuis: ${routesDir}`);
+    }
+    if (config.isDev) {
+      if (verbose) {
+        primaryLog("\u{1F525} Mode de d\xE9veloppement activ\xE9");
+      }
+    }
+    const adapter = getAdapter(platform);
+    const handler = adapter.createHandler(routesDir);
+    let server;
+    switch (platform) {
+      case "node":
+        server = await handler(config);
+        serverInstance = server;
+        break;
+      case "bun":
+        server = handler(config);
+        break;
+      case "vercel":
+      case "netlify":
+        server = handler;
+        break;
+      default:
+        throw new Error(`Plateforme "${platform}" non support\xE9e`);
+    }
+    setupGracefulShutdown();
+    return server;
+  } catch (error) {
+    if (verbose) {
+      primaryLog("\u274C Erreur lors de la cr\xE9ation du serveur:", error);
+    }
+    throw error;
+  }
+}
+function setupGracefulShutdown() {
+  if (!cluster.isPrimary) return;
+  if (shutdownListenersRegistered) return;
+  shutdownListenersRegistered = true;
+  const shutdown = async (signal) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    primaryLog(`
+Signal ${signal} re\xE7u, arr\xEAt en cours...`);
+    if (serverInstance && typeof serverInstance.close === "function") {
+      await new Promise((resolve) => {
+        serverInstance.close(() => resolve());
+        setTimeout(() => {
+          primaryLog("Fermeture forc\xE9e apr\xE8s d\xE9lai");
+          resolve();
+        }, 3e3);
+      });
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGHUP", () => shutdown("SIGHUP"));
+}
+
+// src/core/errors.ts
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+var DEFAULT_ERROR_MESSAGES = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+function createHttpError(options) {
+  const code = options.code || HTTP_STATUS.INTERNAL_SERVER_ERROR;
+  const message = options.message || DEFAULT_ERROR_MESSAGES[code] || "Unknown Error";
+  const name = options.name || `HttpError${code}`;
+  const stackCapture = new Error(message);
+  Error.captureStackTrace?.(stackCapture, createHttpError);
+  return {
+    name,
+    code,
+    message,
+    details: options.details,
+    expose: options.expose !== void 0 ? options.expose : code < 500,
+    log: options.log !== void 0 ? options.log : code >= 500,
+    stack: stackCapture.stack
+  };
+}
+function errorToJSON(error) {
+  const result = {
+    error: error.message,
+    code: error.code
+  };
+  if (error.expose && error.details) {
+    return { ...result, details: error.details };
+  }
+  return result;
+}
+function sendError(error, res) {
+  if (!res.headersSent) {
+    res.statusCode = error.code;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(errorToJSON(error)));
+  }
+  if (error.log) {
+    logError(error);
+  }
+}
+function logError(error) {
+  const logData = {
+    name: error.name,
+    message: error.message,
+    code: error.code,
+    details: error.details,
+    stack: error.stack
+  };
+  if (error.code >= 500) {
+    primaryLog("\u274C ERROR:", JSON.stringify(logData, null, 2));
+  } else {
+    primaryLog("\u26A0\uFE0F WARNING:", JSON.stringify(logData, null, 2));
+  }
+}
+function createBadRequestError(message, details) {
+  return createHttpError({
+    name: "BadRequestError",
+    code: HTTP_STATUS.BAD_REQUEST,
+    message,
+    details
+  });
+}
+function createUnauthorizedError(message, details) {
+  return createHttpError({
+    name: "UnauthorizedError",
+    code: HTTP_STATUS.UNAUTHORIZED,
+    message,
+    details
+  });
+}
+function createForbiddenError(message, details) {
+  return createHttpError({
+    name: "ForbiddenError",
+    code: HTTP_STATUS.FORBIDDEN,
+    message,
+    details
+  });
+}
+function createNotFoundError(message, details) {
+  return createHttpError({
+    name: "NotFoundError",
+    code: HTTP_STATUS.NOT_FOUND,
+    message,
+    details
+  });
+}
+function createMethodNotAllowedError(message, details) {
+  return createHttpError({
+    name: "MethodNotAllowedError",
+    code: HTTP_STATUS.METHOD_NOT_ALLOWED,
+    message,
+    details
+  });
+}
+function createConflictError(message, details) {
+  return createHttpError({
+    name: "ConflictError",
+    code: HTTP_STATUS.CONFLICT,
+    message,
+    details
+  });
+}
+function createValidationError(message, details) {
+  return createHttpError({
+    name: "ValidationError",
+    code: HTTP_STATUS.UNPROCESSABLE_ENTITY,
+    message,
+    details,
+    expose: true
+  });
+}
+function createRateLimitError(message, details) {
+  return createHttpError({
+    name: "RateLimitError",
+    code: HTTP_STATUS.TOO_MANY_REQUESTS,
+    message,
+    details
+  });
+}
+function createInternalServerError(message, details) {
+  return createHttpError({
+    name: "InternalServerError",
+    code: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    message,
+    details
+  });
+}
+function createServiceUnavailableError(message, details) {
+  return createHttpError({
+    name: "ServiceUnavailableError",
+    code: HTTP_STATUS.SERVICE_UNAVAILABLE,
+    message,
+    details
+  });
+}
+function createGatewayTimeoutError(message, details) {
+  return createHttpError({
+    name: "GatewayTimeoutError",
+    code: HTTP_STATUS.GATEWAY_TIMEOUT,
+    message,
+    details
+  });
+}
+function normalizeError(error) {
+  if (error && typeof error === "object" && typeof error.code === "number" && "message" in error) {
+    return error;
+  }
+  const message = error?.message || "Unknown error occurred";
+  const details = error?.stack ? { stack: error.stack } : void 0;
+  const errorCode = error?.code || error?.statusCode;
+  if (errorCode === "ECONNREFUSED" || errorCode === "ENOTFOUND") {
+    return createServiceUnavailableError(
+      `Service connection failed: ${message}`,
+      details
+    );
+  }
+  if (errorCode === "ETIMEDOUT") {
+    return createGatewayTimeoutError(`Request timed out: ${message}`, details);
+  }
+  if (typeof errorCode === "number" && errorCode >= 400 && errorCode < 600) {
+    return createHttpError({
+      code: errorCode,
+      message,
+      details
+    });
+  }
+  return createInternalServerError(message, details);
+}
+function isHttpError(error) {
+  return !!(error && typeof error === "object" && typeof error.code === "number" && "message" in error && "name" in error);
+}
+
+// src/core/rateLimit.ts
+function createRateLimit(options = {}) {
+  const windowMs = options.windowMs ?? 6e4;
+  const max = options.max ?? 100;
+  const message = options.message ?? "Too Many Requests";
+  const keyGenerator = options.keyGenerator ?? ((req) => {
+    const forwarded = req.headers["x-forwarded-for"];
+    return (typeof forwarded === "string" ? forwarded.split(",")[0].trim() : req.socket?.remoteAddress) ?? "unknown";
+  });
+  const store = /* @__PURE__ */ new Map();
+  return (req, res) => {
+    const key = keyGenerator(req);
+    const now = Date.now();
+    let entry = store.get(key);
+    if (!entry || now >= entry.resetAt) {
+      entry = { count: 0, resetAt: now + windowMs };
+      store.set(key, entry);
+    }
+    entry.count++;
+    const remaining = Math.max(0, max - entry.count);
+    const resetSecs = Math.ceil(entry.resetAt / 1e3);
+    res.setHeader("X-RateLimit-Limit", String(max));
+    res.setHeader("X-RateLimit-Remaining", String(remaining));
+    res.setHeader("X-RateLimit-Reset", String(resetSecs));
+    if (entry.count > max) {
+      res.setHeader(
+        "Retry-After",
+        String(Math.ceil((entry.resetAt - now) / 1e3))
+      );
+      sendError(createRateLimitError(message), res);
+      return false;
+    }
+  };
+}
+
+export { HTTP_STATUS, buildOpenApiDoc, createBadRequestError, createConflictError, createForbiddenError, createGatewayTimeoutError, createHttpError, createInternalServerError, createMethodNotAllowedError, createNotFoundError, createRateLimit, createRateLimitError, createServer, createServiceUnavailableError, createUnauthorizedError, createValidationError, defaultConfig, defineHandler, getConfig, isHttpError, logError, normalizeError, sendError };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "lacis",
+  "version": "0.2.0",
+  "description": "Zero-dependency TypeScript web framework",
+  "type": "module",
+  "module": "index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./adapters": {
+      "import": "./dist/adapters/index.js",
+      "types": "./dist/adapters/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/preset-env": "^7.29.5",
+    "@types/bun": "latest",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.5",
+    "@types/supertest": "^7.2.0",
+    "@valibot/to-json-schema": "^1.7.0",
+    "arktype": "^2.2.0",
+    "babel-jest": "^29.7.0",
+    "jest": "^29.7.0",
+    "supertest": "^7.2.2",
+    "ts-jest": "^29.2.6",
+    "tsup": "^8.5.1",
+    "valibot": "^1.4.0",
+    "zod": "^4.4.3",
+    "zod-to-json-schema": "^3.25.2"
+  },
+  "peerDependencies": {
+    "@types/node": ">=18",
+    "typescript": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    },
+    "@types/node": {
+      "optional": true
+    }
+  },
+  "bin": {
+    "lacis": "dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "test": "jest",
+    "test:unit": "jest --selectProjects unit",
+    "test:integration": "jest --selectProjects integration"
+  }
+}