fexapi 0.1.0 → 0.1.1

package/README.md

@@ -3,15 +3,129 @@
 Frontend Experience API - Mock API generation CLI tool for local development and testing.
 
 ## Installation
+
 ```bash
 npm install -g fexapi
 ```
 
 ## Usage
+
 ```bash
 fexapi [options]
 ```
 
+## Prisma-like Flow (Dynamic)
+
+### 1) Initialize
+
+```bash
+pnpm dlx fexapi init
+```
+
+Creates:
+
+- `fexapi/schema.fexapi`
+- `fexapi.config.json`
+
+### 2) Edit schema file
+
+`fexapi/schema.fexapi` uses a simple DSL with only `:` and `,` (no semicolons):
+
+```txt
+# Server
+port: 4100
+
+# Routes
+GET /users: id:uuid,name:name,email:email,age:number,phone:phone,pic:url,courseName:string
+GET /courses: id:uuid,courseName:string,mentor:name
+```
+
+### 3) Generate artifacts (like migrations)
+
+```bash
+npx fexapi generate
+```
+
+Generates:
+
+- `fexapi/generated.api.json`
+- `fexapi/migrations/*.json`
+
+### 4) Start server
+
+```bash
+npx fexapi run
+# or
+npx fexapi serve
+# or (inside local workspace package)
+npm run serve
+```
+
+Server port is read from `schema.fexapi` unless overridden by CLI `--port`.
+
+## Configuration File Support
+
+Create a `fexapi.config.js` in your project root:
+
+```js
+// fexapi.config.js
+module.exports = {
+  port: 3000,
+  routes: {
+    "/users": { count: 50, schema: "user" },
+    "/posts": { count: 100, schema: "post" },
+  },
+  cors: true,
+  delay: 200,
+};
+```
+
+Then run:
+
+```bash
+fexapi serve
+```
+
+Notes:
+
+- `port` sets the default server port (CLI `--port` still has priority).
+- `routes` maps endpoint paths to generated payload settings.
+- `schema` maps to files under `schemas/` (for example `schema: "user"` -> `schemas/user.yaml`); unknown names fall back to a generic record.
+- `cors: true` enables CORS headers and OPTIONS preflight handling.
+- `delay` adds response latency in milliseconds.
+
+## Custom Schema Definitions
+
+You can define custom schemas in YAML files under `schemas/`.
+
+```yaml
+# schemas/user.yaml
+name:
+  type: string
+  faker: person.fullName
+email:
+  type: string
+  faker: internet.email
+age:
+  type: number
+  min: 18
+  max: 80
+```
+
+Then reference it in `fexapi.config.js`:
+
+```js
+routes: {
+  "/users": { count: 50, schema: "user" }
+}
+```
+
+Notes:
+
+- Supported file extensions: `.yaml`, `.yml`
+- Schema name is taken from filename (for example `schemas/user.yaml` -> `schema: "user"`)
+- `faker` values map to Faker paths like `person.fullName`, `internet.email`
+
 ## Features
 
 - Schema-based mock API generation
@@ -21,4 +135,4 @@ fexapi [options]
 
 ## License
 
-MIT
+MIT

package/dist/cli/args.d.ts

@@ -0,0 +1,15 @@
+export declare const parseInitOptions: (initArgs: string[]) => {
+    force: boolean;
+} | {
+    error: string;
+};
+export declare const parseGenerateOptions: (generateArgs: string[]) => {
+    error?: string;
+};
+export declare const parseServeOptions: (serveArgs: string[]) => {
+    host: string;
+    port?: number;
+} | {
+    error: string;
+};
+//# sourceMappingURL=args.d.ts.map

package/dist/cli/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAAE,KACjB;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAWtC,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,cAAc,MAAM,EAAE,KACrB;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAQlB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,EAAE,KAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CA+CnD,CAAC"}

package/dist/cli/args.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseServeOptions = exports.parseGenerateOptions = exports.parseInitOptions = void 0;
+const parseInitOptions = (initArgs) => {
+    const validFlags = new Set(["--force"]);
+    const invalidFlags = initArgs.filter((value) => value.startsWith("-") && !validFlags.has(value));
+    if (invalidFlags.length > 0) {
+        return { error: `Unknown option(s): ${invalidFlags.join(", ")}` };
+    }
+    return { force: initArgs.includes("--force") };
+};
+exports.parseInitOptions = parseInitOptions;
+const parseGenerateOptions = (generateArgs) => {
+    const invalidFlags = generateArgs.filter((value) => value.startsWith("-"));
+    if (invalidFlags.length > 0) {
+        return { error: `Unknown option(s): ${invalidFlags.join(", ")}` };
+    }
+    return {};
+};
+exports.parseGenerateOptions = parseGenerateOptions;
+const parseServeOptions = (serveArgs) => {
+    const getFlagValue = (flagName) => {
+        const index = serveArgs.indexOf(flagName);
+        if (index === -1) {
+            return undefined;
+        }
+        const value = serveArgs[index + 1];
+        if (!value || value.startsWith("-")) {
+            return { error: `Missing value for ${flagName}` };
+        }
+        return value;
+    };
+    const unknownFlags = serveArgs.filter((value) => value.startsWith("-") && value !== "--host" && value !== "--port");
+    if (unknownFlags.length > 0) {
+        return { error: `Unknown option(s): ${unknownFlags.join(", ")}` };
+    }
+    const hostValue = getFlagValue("--host");
+    if (hostValue && typeof hostValue !== "string") {
+        return hostValue;
+    }
+    const portValue = getFlagValue("--port");
+    if (portValue && typeof portValue !== "string") {
+        return portValue;
+    }
+    const host = hostValue ?? "127.0.0.1";
+    const port = portValue ? Number(portValue) : undefined;
+    if (port !== undefined &&
+        (!Number.isInteger(port) || port < 1 || port > 65535)) {
+        return { error: `Invalid port: ${portValue ?? ""}`.trim() };
+    }
+    return { host, port };
+};
+exports.parseServeOptions = parseServeOptions;

package/dist/cli/help.d.ts

@@ -0,0 +1,2 @@
+export declare const printHelp: () => void;
+//# sourceMappingURL=help.d.ts.map

package/dist/cli/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/cli/help.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,YAmCrB,CAAC"}

package/dist/cli/help.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = void 0;
+const printHelp = () => {
+    console.log("fexapi-cli");
+    console.log("");
+    console.log("Usage:");
+    console.log("  fexapi init [--force]");
+    console.log("  fexapi generate");
+    console.log("  fexapi serve [--host <host>] [--port <number>]");
+    console.log("  fexapi run [--host <host>] [--port <number>]");
+    console.log("  fexapi [--host <host>] [--port <number>]");
+    console.log("  fexapi --help");
+    console.log("");
+    console.log("Examples:");
+    console.log("  fexapi init");
+    console.log("  fexapi init --force");
+    console.log("  fexapi generate");
+    console.log("  fexapi serve --host 127.0.0.1 --port 5000");
+    console.log("  fexapi --port 4000");
+    console.log("");
+    console.log("Package manager usage:");
+    console.log("  npx fexapi init");
+    console.log("  pnpm dlx fexapi init");
+    console.log("  yarn dlx fexapi init");
+    console.log("");
+    console.log("`fexapi init` creates:");
+    console.log("  fexapi.config.json");
+    console.log("  fexapi/schema.fexapi");
+    console.log("");
+    console.log("Then run:");
+    console.log("  # edit fexapi/schema.fexapi");
+    console.log("  fexapi generate");
+    console.log("  fexapi run");
+    console.log("");
+    console.log("Generate output:");
+    console.log("  fexapi/generated.api.json");
+    console.log("  fexapi/migrations/*.json");
+};
+exports.printHelp = printHelp;

package/dist/commands/generate.d.ts

@@ -0,0 +1,2 @@
+export declare const generateFromSchema: () => number;
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/commands/generate.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,kBAAkB,QAAO,MAkGrC,CAAC"}

package/dist/commands/generate.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFromSchema = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const constants_1 = require("../constants");
+const paths_1 = require("../project/paths");
+const schema_1 = require("../schema");
+const generateFromSchema = () => {
+    const projectRoot = (0, paths_1.resolveProjectRoot)();
+    if (!projectRoot) {
+        console.error("Could not find package.json in this directory or parent directories.");
+        return 1;
+    }
+    const schemaPath = (0, node_path_1.join)(projectRoot, "fexapi", "schema.fexapi");
+    const generatedPath = (0, node_path_1.join)(projectRoot, "fexapi", "generated.api.json");
+    const migrationsDirectoryPath = (0, node_path_1.join)(projectRoot, "fexapi", "migrations");
+    const configPath = (0, node_path_1.join)(projectRoot, "fexapi.config.json");
+    if (!(0, node_fs_1.existsSync)(schemaPath)) {
+        console.error(`Schema file not found: ${schemaPath}`);
+        console.error("Run `fexapi init` first.");
+        return 1;
+    }
+    const schemaText = (0, node_fs_1.readFileSync)(schemaPath, "utf-8");
+    const parsed = (0, schema_1.parseFexapiSchema)(schemaText);
+    if (parsed.errors.length > 0 || !parsed.schema) {
+        console.error("Failed to generate API from schema.fexapi");
+        for (const error of parsed.errors) {
+            console.error(`- ${error}`);
+        }
+        return 1;
+    }
+    const generated = {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        port: parsed.schema.port,
+        routes: parsed.schema.routes,
+    };
+    (0, node_fs_1.mkdirSync)(migrationsDirectoryPath, { recursive: true });
+    const migrationId = new Date().toISOString().replace(/[.:]/g, "-");
+    const migrationPath = (0, node_path_1.join)(migrationsDirectoryPath, `${migrationId}_schema.json`);
+    const migration = {
+        migrationId,
+        sourceSchema: "fexapi/schema.fexapi",
+        createdAt: generated.generatedAt,
+        port: parsed.schema.port,
+        routes: parsed.schema.routes,
+    };
+    (0, node_fs_1.writeFileSync)(generatedPath, `${JSON.stringify(generated, null, 2)}\n`, "utf-8");
+    (0, node_fs_1.writeFileSync)(migrationPath, `${JSON.stringify(migration, null, 2)}\n`, "utf-8");
+    let existingConfig = {};
+    if ((0, node_fs_1.existsSync)(configPath)) {
+        try {
+            existingConfig = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+        }
+        catch {
+            existingConfig = {};
+        }
+    }
+    const updatedConfig = {
+        ...existingConfig,
+        schemaPath: "fexapi/schema.fexapi",
+        generatedPath: constants_1.GENERATED_SPEC_RELATIVE_PATH,
+        lastGeneratedAt: new Date().toISOString(),
+    };
+    (0, node_fs_1.writeFileSync)(configPath, `${JSON.stringify(updatedConfig, null, 2)}\n`, "utf-8");
+    console.log(`Generated API spec at ${generatedPath}`);
+    console.log(`Migration created at ${migrationPath}`);
+    console.log(`Routes generated: ${parsed.schema.routes.length}`);
+    console.log(`Configured server port: ${parsed.schema.port}`);
+    return 0;
+};
+exports.generateFromSchema = generateFromSchema;

package/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare const initializeProject: ({ force }: {
+    force: boolean;
+}) => number;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB,GAAI,WAAW;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,KAAG,MAwEjE,CAAC"}

package/dist/commands/init.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeProject = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const constants_1 = require("../constants");
+const detect_1 = require("../project/detect");
+const paths_1 = require("../project/paths");
+const initializeProject = ({ force }) => {
+    const packageJsonPath = (0, paths_1.findClosestPackageJson)(process.cwd());
+    if (!packageJsonPath) {
+        console.error("Could not find package.json in this directory or parent directories.");
+        return 1;
+    }
+    const projectRoot = (0, node_path_1.dirname)(packageJsonPath);
+    const detectedProject = (0, detect_1.detectProject)(packageJsonPath, projectRoot);
+    const fexapiDirectoryPath = (0, node_path_1.join)(projectRoot, "fexapi");
+    const schemaPath = (0, node_path_1.join)(fexapiDirectoryPath, "schema.fexapi");
+    const configPath = (0, node_path_1.join)(projectRoot, "fexapi.config.json");
+    (0, node_fs_1.mkdirSync)(fexapiDirectoryPath, { recursive: true });
+    const configExists = (0, node_fs_1.existsSync)(configPath);
+    const schemaExists = (0, node_fs_1.existsSync)(schemaPath);
+    const config = {
+        framework: detectedProject.primaryFramework,
+        frameworks: detectedProject.frameworks,
+        tooling: detectedProject.tooling,
+        schemaPath: "fexapi/schema.fexapi",
+        generatedPath: constants_1.GENERATED_SPEC_RELATIVE_PATH,
+        createdAt: new Date().toISOString(),
+    };
+    if (!configExists || force) {
+        (0, node_fs_1.writeFileSync)(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    }
+    if (!schemaExists || force) {
+        (0, node_fs_1.writeFileSync)(schemaPath, `${(0, detect_1.getSchemaTemplate)(detectedProject.primaryFramework)}\n`, "utf-8");
+    }
+    console.log(`Initialized Fexapi in ${projectRoot}`);
+    console.log(`Detected framework: ${detectedProject.primaryFramework}`);
+    console.log(`Detected frameworks: ${detectedProject.frameworks.join(", ")}`);
+    if (detectedProject.tooling.length > 0) {
+        console.log(`Detected tooling: ${detectedProject.tooling.join(", ")}`);
+    }
+    if (configExists && !force) {
+        console.log(`Exists ${configPath}`);
+    }
+    else if (configExists && force) {
+        console.log(`Overwritten ${configPath}`);
+    }
+    else {
+        console.log(`Created ${configPath}`);
+    }
+    if (schemaExists && !force) {
+        console.log(`Exists ${schemaPath}`);
+    }
+    else if (schemaExists && force) {
+        console.log(`Overwritten ${schemaPath}`);
+    }
+    else {
+        console.log(`Created ${schemaPath}`);
+    }
+    if (detectedProject.primaryFramework === "unknown") {
+        console.log("No known framework dependency found. Update fexapi.config.json and schema.fexapi if needed.");
+    }
+    return 0;
+};
+exports.initializeProject = initializeProject;

package/dist/commands/serve.d.ts

@@ -0,0 +1,5 @@
+export declare const serveProject: ({ host, port, }: {
+    host: string;
+    port?: number;
+}) => number;
+//# sourceMappingURL=serve.d.ts.map

package/dist/commands/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/commands/serve.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,YAAY,GAAI,iBAG1B;IACD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,KAAG,MAkEH,CAAC"}

package/dist/commands/serve.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveProject = void 0;
+const constants_1 = require("../constants");
+const generated_spec_1 = require("../config/generated-spec");
+const runtime_config_1 = require("../config/runtime-config");
+const schema_definitions_1 = require("../config/schema-definitions");
+const paths_1 = require("../project/paths");
+const server_1 = require("../server");
+const serveProject = ({ host, port, }) => {
+    const projectRoot = (0, paths_1.resolveProjectRoot)();
+    const runtimeConfig = projectRoot
+        ? (0, runtime_config_1.loadFexapiRuntimeConfig)(projectRoot)
+        : undefined;
+    const schemaDefinitions = projectRoot
+        ? (0, schema_definitions_1.loadSchemaDefinitions)(projectRoot)
+        : {};
+    const generatedSpec = projectRoot
+        ? (0, generated_spec_1.loadGeneratedApiSpec)(projectRoot)
+        : undefined;
+    const effectivePort = port ?? runtimeConfig?.port ?? generatedSpec?.port ?? 4000;
+    if (runtimeConfig?.routes && Object.keys(runtimeConfig.routes).length > 0) {
+        console.log(`Using routes from fexapi.config.js (${Object.keys(runtimeConfig.routes).length})`);
+    }
+    if (Object.keys(schemaDefinitions).length > 0) {
+        console.log(`Loaded custom schemas from /schemas (${Object.keys(schemaDefinitions).length})`);
+    }
+    if (generatedSpec &&
+        !(runtimeConfig?.routes && Object.keys(runtimeConfig.routes).length > 0)) {
+        console.log(`Using generated schema routes (${generatedSpec.routes.length}) from ${constants_1.GENERATED_SPEC_RELATIVE_PATH}`);
+    }
+    else if (!runtimeConfig?.routes ||
+        Object.keys(runtimeConfig.routes).length === 0) {
+        console.log("No generated schema found. Run `fexapi generate` to serve schema-defined endpoints.");
+    }
+    const server = (0, server_1.startServer)({
+        host,
+        port: effectivePort,
+        apiSpec: generatedSpec,
+        runtimeConfig,
+        schemaDefinitions,
+    });
+    const shutdown = () => {
+        server.close((error) => {
+            if (error) {
+                console.error("Error while shutting down server", error);
+                process.exit(1);
+            }
+            process.exit(0);
+        });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    return 0;
+};
+exports.serveProject = serveProject;

package/dist/config/generated-spec.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedApiSpec } from "../server";
+export declare const loadGeneratedApiSpec: (projectRoot: string) => GeneratedApiSpec | undefined;
+//# sourceMappingURL=generated-spec.d.ts.map

package/dist/config/generated-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-spec.d.ts","sourceRoot":"","sources":["../../src/config/generated-spec.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD,eAAO,MAAM,oBAAoB,GAC/B,aAAa,MAAM,KAClB,gBAAgB,GAAG,SAwBrB,CAAC"}

package/dist/config/generated-spec.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGeneratedApiSpec = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const constants_1 = require("../constants");
+const loadGeneratedApiSpec = (projectRoot) => {
+    const generatedPath = (0, node_path_1.join)(projectRoot, constants_1.GENERATED_SPEC_RELATIVE_PATH);
+    if (!(0, node_fs_1.existsSync)(generatedPath)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(generatedPath, "utf-8"));
+        if (typeof parsed.port !== "number" || !Array.isArray(parsed.routes)) {
+            return undefined;
+        }
+        return {
+            port: parsed.port,
+            routes: parsed.routes,
+        };
+    }
+    catch {
+        return undefined;
+    }
+};
+exports.loadGeneratedApiSpec = loadGeneratedApiSpec;

package/dist/config/runtime-config.d.ts

@@ -0,0 +1,3 @@
+import type { FexapiRuntimeConfig } from "../types/config";
+export declare const loadFexapiRuntimeConfig: (projectRoot: string) => FexapiRuntimeConfig | undefined;
+//# sourceMappingURL=runtime-config.d.ts.map

package/dist/config/runtime-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-config.d.ts","sourceRoot":"","sources":["../../src/config/runtime-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAqB,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAU9E,eAAO,MAAM,uBAAuB,GAClC,aAAa,MAAM,KAClB,mBAAmB,GAAG,SA8GxB,CAAC"}

package/dist/config/runtime-config.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFexapiRuntimeConfig = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const normalizePath = (value) => {
+    return value.startsWith("/") ? value : `/${value}`;
+};
+const loadFexapiRuntimeConfig = (projectRoot) => {
+    const configPath = (0, node_path_1.join)(projectRoot, "fexapi.config.js");
+    if (!(0, node_fs_1.existsSync)(configPath)) {
+        return undefined;
+    }
+    try {
+        const source = (0, node_fs_1.readFileSync)(configPath, "utf-8");
+        const moduleShim = { exports: {} };
+        const exportsShim = {};
+        const executeModule = new Function("module", "exports", source);
+        executeModule(moduleShim, exportsShim);
+        const rawConfig = moduleShim.exports;
+        if (!isRecord(rawConfig)) {
+            console.error("Invalid fexapi.config.js: expected an object export.");
+            return undefined;
+        }
+        const normalizedConfig = {};
+        if (rawConfig.port !== undefined) {
+            if (typeof rawConfig.port !== "number" ||
+                !Number.isInteger(rawConfig.port) ||
+                rawConfig.port < 1 ||
+                rawConfig.port > 65535) {
+                console.error("Invalid fexapi.config.js: `port` must be an integer between 1 and 65535.");
+            }
+            else {
+                normalizedConfig.port = rawConfig.port;
+            }
+        }
+        if (rawConfig.cors !== undefined) {
+            if (typeof rawConfig.cors !== "boolean") {
+                console.error("Invalid fexapi.config.js: `cors` must be true or false.");
+            }
+            else {
+                normalizedConfig.cors = rawConfig.cors;
+            }
+        }
+        if (rawConfig.delay !== undefined) {
+            if (typeof rawConfig.delay !== "number" ||
+                !Number.isFinite(rawConfig.delay) ||
+                rawConfig.delay < 0) {
+                console.error("Invalid fexapi.config.js: `delay` must be a non-negative number.");
+            }
+            else {
+                normalizedConfig.delay = Math.floor(rawConfig.delay);
+            }
+        }
+        if (rawConfig.routes !== undefined) {
+            if (!isRecord(rawConfig.routes)) {
+                console.error("Invalid fexapi.config.js: `routes` must be an object.");
+            }
+            else {
+                const normalizedRoutes = {};
+                for (const [pathKey, routeValue] of Object.entries(rawConfig.routes)) {
+                    if (!isRecord(routeValue)) {
+                        console.error(`Invalid fexapi.config.js route at ${pathKey}: expected an object with count and schema.`);
+                        continue;
+                    }
+                    const schemaValue = routeValue.schema;
+                    if (typeof schemaValue !== "string" ||
+                        schemaValue.trim().length === 0) {
+                        console.error(`Invalid fexapi.config.js route at ${pathKey}: schema must be a non-empty string.`);
+                        continue;
+                    }
+                    const countValue = routeValue.count;
+                    const normalizedCount = typeof countValue === "number" &&
+                        Number.isInteger(countValue) &&
+                        countValue > 0
+                        ? countValue
+                        : 10;
+                    normalizedRoutes[normalizePath(pathKey)] = {
+                        count: normalizedCount,
+                        schema: schemaValue.trim(),
+                    };
+                }
+                normalizedConfig.routes = normalizedRoutes;
+            }
+        }
+        return normalizedConfig;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to load fexapi.config.js: ${message}`);
+        return undefined;
+    }
+};
+exports.loadFexapiRuntimeConfig = loadFexapiRuntimeConfig;

package/dist/config/schema-definitions.d.ts

@@ -0,0 +1,3 @@
+import type { FexapiSchemaDefinitions } from "../types/config";
+export declare const loadSchemaDefinitions: (projectRoot: string) => FexapiSchemaDefinitions;
+//# sourceMappingURL=schema-definitions.d.ts.map

package/dist/config/schema-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-definitions.d.ts","sourceRoot":"","sources":["../../src/config/schema-definitions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAGV,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AA8EzB,eAAO,MAAM,qBAAqB,GAChC,aAAa,MAAM,KAClB,uBAoCF,CAAC"}