transit-kit 0.1.0 → 0.2.0

package/dist/cli/cli.js

@@ -9,9 +9,10 @@ program
 program
     .command("generate-openapi")
     .option("-o, --output <path>", "Output path for the generated OpenAPI document", "openapi.json")
+    .option("-t, --target <path>", "Target path to search for endpoint definitions", ".")
     .action(async (options) => {
-    const { output } = options;
-    const generatedDoc = await generateOpenApiDoc();
+    const { output, target } = options;
+    const generatedDoc = await generateOpenApiDoc(target);
     fs.writeFileSync(output, JSON.stringify(generatedDoc, null, 2), {
         encoding: "utf-8",
     });

package/dist/cli/generateOpenApi.d.ts

@@ -1,2 +1,2 @@
 import { OpenAPIV3 } from "openapi-types";
-export declare function generateOpenApiDoc(): Promise<OpenAPIV3.Document<{}>>;
+export declare function generateOpenApiDoc(targetPath: string): Promise<OpenAPIV3.Document<{}>>;

package/dist/cli/generateOpenApi.js

@@ -1,38 +1,7 @@
-import { glob } from "glob";
-import path from "path";
 import z from "zod";
-import { hasNoValue, hasValue } from "../server/utils/typeGuards";
+import { hasValue } from "../server/utils/typeGuards";
+import path from "path";
 import { isJsonResponseSchema } from "../server/handlers/api/responses/jsonResponse";
-async function findEndpointDefinitions() {
-    const files = await glob("**/*.ts", {
-        cwd: process.cwd(),
-        ignore: ["**/node_modules/**", "**/*.spec.ts"],
-    });
-    const definitions = await Promise.all(files.map(async (file) => {
-        const absolutePath = path.resolve(file);
-        const fileUrl = path.toNamespacedPath(absolutePath).startsWith("/")
-            ? `file://${absolutePath}`
-            : `file:///${absolutePath}`;
-        try {
-            const module = await import(fileUrl);
-            if (module.default) {
-                const def = module.default.__API_ENDPOINT_DEFINITION__;
-                if (hasNoValue(def)) {
-                    return null;
-                }
-                return def;
-            }
-            else {
-                return null;
-            }
-        }
-        catch (error) {
-            console.error(`Error importing ${file}:`, error);
-            return null;
-        }
-    }));
-    return definitions.filter(hasValue);
-}
 function extractPathAndParameters(path) {
     const parameters = path.match(/:([a-zA-Z0-9_]+)/g)?.map((param) => {
         return {
@@ -125,28 +94,37 @@ function translateToOpenAPIPathItem(definition) {
     };
     return [openApiPath, pathItem];
 }
-export async function generateOpenApiDoc() {
-    const definitions = await findEndpointDefinitions();
-    const paths = definitions.reduce((acc, def) => {
-        const [openApiPath, pathItem] = translateToOpenAPIPathItem(def);
-        if (acc[openApiPath]) {
-            acc[openApiPath] = {
-                ...acc[openApiPath],
-                ...pathItem,
-            };
-        }
-        else {
-            acc[openApiPath] = pathItem;
-        }
-        return acc;
-    }, {});
-    const openApiDocument = {
-        openapi: "3.0.0",
-        info: {
-            title: "Generated API",
-            version: "1.0.0",
-        },
-        paths: paths,
-    };
-    return openApiDocument;
+export async function generateOpenApiDoc(targetPath) {
+    const serverModule = await import(path.resolve(process.cwd(), targetPath));
+    const server = serverModule.default;
+    if (hasValue(server) &&
+        hasValue(server.endpointDefinitions) &&
+        Array.isArray(server.endpointDefinitions)) {
+        const endpointDefinitions = server.endpointDefinitions;
+        const paths = endpointDefinitions.reduce((acc, def) => {
+            const [openApiPath, pathItem] = translateToOpenAPIPathItem(def);
+            if (acc[openApiPath]) {
+                acc[openApiPath] = {
+                    ...acc[openApiPath],
+                    ...pathItem,
+                };
+            }
+            else {
+                acc[openApiPath] = pathItem;
+            }
+            return acc;
+        }, {});
+        const openApiDocument = {
+            openapi: "3.0.0",
+            info: {
+                title: "Generated API",
+                version: "1.0.0",
+            },
+            paths: paths,
+        };
+        return openApiDocument;
+    }
+    else {
+        throw new Error("The specified module does not export a valid server instance.");
+    }
 }

package/dist/server/handlers/api/createApiHandler.d.ts

@@ -5,7 +5,7 @@ import { ApiEndpointHandler } from "./EndpointHandler";
 import { HandlerForDefinition } from "./HandlerFromDefinition";
 import { GenericResponseSchemaMap } from "./responses";
 export declare function createApiEndpointHandler<const ResponsesMap extends GenericResponseSchemaMap, const Path extends string, const Method extends HttpMethod, const RequestBody extends z.ZodType | undefined = undefined, const Query extends z.ZodType | undefined = undefined>(definition: ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponsesMap>, handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap>): {
-    __API_ENDPOINT_DEFINITION__: ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponsesMap>;
+    type: string;
     definition: ApiEndpointDefinition<Path, Method, RequestBody, Query, ResponsesMap>;
     handler: HandlerForDefinition<Path, RequestBody, Query, ResponsesMap>;
 };

package/dist/server/handlers/api/createApiHandler.js

@@ -2,7 +2,7 @@ import expressAsyncHandler from "express-async-handler";
 import { isJsonResponse } from "./responses/jsonResponse";
 export function createApiEndpointHandler(definition, handler) {
     return {
-        __API_ENDPOINT_DEFINITION__: definition,
+        type: "__API_ENDPOINT_DEFINITION__",
         definition,
         handler,
     };

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
 export { createApiEndpointHandler } from "./handlers/api/createApiHandler";
-export { createServer, type Server, type ServerOptions } from "./server";
+export { createServer, type Server, type ServerConfig } from "./server";
 declare const _default: {};
 export default _default;

package/dist/server/server.d.ts

@@ -4,18 +4,19 @@ import { HttpMethod } from "./constants/HttpMethods";
 import { ApiEndpointDefinition } from "./handlers/api/EndpointDefinition";
 import { ApiEndpointHandler } from "./handlers/api/EndpointHandler";
 import { Logger } from "./utils/logging";
-export interface ServerOptions {
-    inDevMode?: boolean;
-    port?: number;
-    logger?: Logger | boolean;
+export interface ServerConfig {
+    inDevMode: boolean;
+    port: number;
+    logger: Logger | boolean;
+    endpoints: Array<{
+        endpointHandler: ApiEndpointHandler;
+        endpointDefinition: ApiEndpointDefinition<string, HttpMethod, z.ZodType, z.ZodType, {}>;
+    }>;
 }
 export interface Server {
-    _expressApp: Application;
-    _logger: Logger | boolean;
+    expressApp: Application;
+    logger: Logger | boolean;
+    endpointDefinitions: ApiEndpointDefinition<string, HttpMethod, z.ZodType, z.ZodType, {}>[];
     start: () => void;
-    registerApiEndpoint: (endpoint: {
-        endpointHandler: ApiEndpointHandler;
-        endpointDefinition: ApiEndpointDefinition<string, HttpMethod, z.ZodType, z.ZodType, {}>;
-    }) => void;
 }
-export declare function createServer(options: ServerOptions): Server;
+export declare function createServer(config: ServerConfig): Server;

package/dist/server/server.js

@@ -5,39 +5,40 @@ import { buildRequestLogger, buildResponseLogger } from "./middleware/logging";
 import { buildBodyValidatorMiddleware, buildQueryValidatorMiddleware, } from "./middleware/validation";
 import { NoOpLogger } from "./utils/logging";
 import { hasNoValue, hasValue } from "./utils/typeGuards";
-export function createServer(options) {
-    const { port = 3000, inDevMode = false } = options;
-    const logger = options.logger === true
+function registerApiEndpoint(expressApp, endpointDefinition, endpointHandler) {
+    const handlerStack = [
+        hasValue(endpointDefinition.querySchema)
+            ? buildQueryValidatorMiddleware(endpointDefinition.querySchema)
+            : null,
+        hasValue(endpointDefinition.requestBodySchema)
+            ? buildBodyValidatorMiddleware(endpointDefinition.requestBodySchema)
+            : null,
+        buildApiEndpointHandler(endpointHandler),
+    ].filter(hasValue);
+    expressApp[endpointDefinition.method](endpointDefinition.path, handlerStack);
+}
+export function createServer(config) {
+    const { port, inDevMode, endpoints } = config;
+    const logger = config.logger === true
         ? console
-        : options.logger === false || hasNoValue(options.logger)
+        : config.logger === false || hasNoValue(config.logger)
             ? NoOpLogger
-            : options.logger;
+            : config.logger;
     const app = express();
     app.use(express.json());
     app.use(express.urlencoded({ extended: true }));
     app.use(cookieParser());
     app.use(buildRequestLogger(logger, inDevMode));
     app.use(buildResponseLogger(logger, inDevMode));
+    endpoints.forEach(({ endpointDefinition, endpointHandler }) => {
+        registerApiEndpoint(app, endpointDefinition, endpointHandler);
+    });
     return {
-        _expressApp: app,
-        _logger: logger,
+        expressApp: app,
+        logger: logger,
+        endpointDefinitions: endpoints.map((e) => e.endpointDefinition),
         start: () => {
             app.listen(port);
         },
-        registerApiEndpoint: ({ endpointDefinition, endpointHandler }) => {
-            registerApiEndpoint(app, endpointDefinition, endpointHandler);
-        },
     };
 }
-function registerApiEndpoint(expressApp, endpointDefinition, endpointHandler) {
-    const handlerStack = [
-        hasValue(endpointDefinition.querySchema)
-            ? buildQueryValidatorMiddleware(endpointDefinition.querySchema)
-            : null,
-        hasValue(endpointDefinition.requestBodySchema)
-            ? buildBodyValidatorMiddleware(endpointDefinition.requestBodySchema)
-            : null,
-        buildApiEndpointHandler(endpointHandler),
-    ].filter(hasValue);
-    expressApp[endpointDefinition.method](endpointDefinition.path, handlerStack);
-}

package/package.json

@@ -1,9 +1,31 @@
 {
   "name": "transit-kit",
-  "version": "0.1.0",
+  "version": "0.2.0",
+  "description": "A declarative TypeScript framework for building type-safe Express.js APIs with automatic OpenAPI generation",
+  "keywords": [
+    "express",
+    "typescript",
+    "api",
+    "openapi",
+    "zod",
+    "rest",
+    "server",
+    "framework"
+  ],
   "type": "module",
   "license": "MIT",
-  "repository": "https://github.com/D4rkr34lm/declarative-server",
+  "author": "D4rkr34lm",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/D4rkr34lm/transit-kit.git"
+  },
+  "homepage": "https://github.com/D4rkr34lm/transit-kit#readme",
+  "bugs": {
+    "url": "https://github.com/D4rkr34lm/transit-kit/issues"
+  },
+  "files": [
+    "dist"
+  ],
   "exports": {
     "./server": {
       "import": "./dist/server/index.js",
@@ -39,7 +61,6 @@
     "cookie-parser": "^1.4.7",
     "express": "^4.21.1",
     "express-async-handler": "^1.2.0",
-    "glob": "^13.0.0",
     "openapi-types": "^12.1.3",
     "zod": "^4.1.13"
   }

package/.github/workflows/ci.yml

@@ -1,73 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main, develop]
-  pull_request:
-    branches: [main, develop]
-
-jobs:
-  lint:
-    name: 🔍 Lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-          cache: "npm"
-
-      - name: 📦 Install dependencies
-        run: npm ci
-
-      - name: ✨ Run linter
-        run: npm run lint
-
-  test:
-    name: 🧪 Test
-    runs-on: ubuntu-latest
-    steps:
-      - name: 📥 Checkout code
-        uses: actions/checkout@v4
-
-      - name: ⚙️ Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-          cache: "npm"
-
-      - name: 📦 Install dependencies
-        run: npm ci
-
-      - name: 🧪 Run tests
-        run: npm run test -- --run
-
-  build:
-    name: 🏗️ Build
-    runs-on: ubuntu-latest
-    needs: [lint, test]
-    steps:
-      - name: 📥 Checkout code
-        uses: actions/checkout@v4
-
-      - name: ⚙️ Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-          cache: "npm"
-
-      - name: 📦 Install dependencies
-        run: npm ci
-
-      - name: 🔨 Build package
-        run: npm run build
-
-      - name: 📤 Upload build artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: dist
-          path: dist/
-          retention-days: 7

package/.github/workflows/release.yml

@@ -1,37 +0,0 @@
-name: Release
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    name: 🚀 Publish to npm
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - name: 📥 Checkout code
-        uses: actions/checkout@v4
-
-      - name: ⚙️ Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-          registry-url: "https://registry.npmjs.org"
-          cache: "npm"
-
-      - name: 📦 Install dependencies
-        run: npm ci
-
-      - name: 🧪 Run tests
-        run: npm run test -- --run
-
-      - name: 🔨 Build package
-        run: npm run build
-
-      - name: 🚀 Publish to npm
-        run: npm publish --provenance
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/eslint-configs/eslint.base.config.js

@@ -1,30 +0,0 @@
-import { globalIgnores } from "eslint/config";
-import { config } from "typescript-eslint";
-
-import eslintJS from "@eslint/js";
-import prettierEslint from "eslint-plugin-prettier/recommended";
-import eslintTS from "typescript-eslint";
-
-export default config(
-  globalIgnores([
-    "*.config.{mjs|js|ts}",
-    "coverage",
-    "dist",
-    "generated",
-    "node_modules",
-  ]),
-  eslintJS.configs.recommended,
-  eslintTS.configs.recommended,
-  {
-    rules: {
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        {
-          argsIgnorePattern: "^_",
-          destructuredArrayIgnorePattern: "^_",
-        },
-      ],
-    },
-  },
-  prettierEslint,
-);

package/eslint-configs/eslint.node.config.js

@@ -1,23 +0,0 @@
-import globals from "globals";
-import { config } from "typescript-eslint";
-
-import baseConfig from "./eslint.base.config.js";
-
-export default config(baseConfig, {
-  files: ["**/*.ts"],
-  languageOptions: {
-    globals: {
-      ...globals.node,
-    },
-  },
-  rules: {
-    "@typescript-eslint/no-empty-object-type": "off",
-    "@typescript-eslint/no-unused-vars": [
-      "error",
-      {
-        argsIgnorePattern: "^_",
-        varsIgnorePattern: "^_",
-      },
-    ],
-  },
-});

package/eslint-configs/eslint.test.config.js

@@ -1,15 +0,0 @@
-import eslintVitest from "@vitest/eslint-plugin";
-import globals from "globals";
-import { config } from "typescript-eslint";
-
-export default config(eslintVitest.configs.recommended, {
-  files: ["**/*.spec.ts"],
-  languageOptions: {
-    globals: {
-      ...globals.vitest,
-    },
-  },
-  rules: {
-    "vitest/expect-expect": "off",
-  },
-});

package/eslint.config.ts

@@ -1,6 +0,0 @@
-import { config } from "typescript-eslint";
-
-import nodeConfig from "./eslint-configs/eslint.node.config";
-import testConfig from "./eslint-configs/eslint.test.config";
-
-export default config(nodeConfig, testConfig);

package/prettier.config.js

@@ -1,14 +0,0 @@
-/**
- * @see https://prettier.io/docs/configuration
- * @type {import("prettier").Config}
- */
-const config = {
-  trailingComma: "all",
-  tabWidth: 2,
-  semi: true,
-  singleQuote: false,
-  printWidth: 80,
-  endOfLine: "lf",
-};
-
-export default config;

package/src/cli/cli.ts

@@ -1,37 +0,0 @@
-import { Command } from "commander";
-import fs from "fs";
-import { generateOpenApiDoc } from "./generateOpenApi";
-
-const program = new Command();
-
-program
-  .name("transit-kit")
-  .description("CLI of the transitKit backend framework")
-
-  .version("1.0.0");
-
-program
-  .command("generate-openapi")
-  .option(
-    "-o, --output <path>",
-
-    "Output path for the generated OpenAPI document",
-    "openapi.json",
-  )
-  .option(
-    "-t, --target <path>",
-    "Target path to search for endpoint definitions",
-    ".",
-  )
-  .action(async (options) => {
-    const { output, target } = options;
-
-    const generatedDoc = await generateOpenApiDoc(target);
-
-    fs.writeFileSync(output, JSON.stringify(generatedDoc, null, 2), {
-      encoding: "utf-8",
-    });
-    console.log(`OpenAPI document generated at: ${output}`);
-  });
-
-program.parse();