fexapi 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# FexAPI
+
+Frontend Experience API - Mock API generation CLI tool for local development and testing.
+
+## Installation
+```bash
+npm install -g fexapi
+```
+
+## Usage
+```bash
+fexapi [options]
+```
+
+## Features
+
+- Schema-based mock API generation
+- Local development server
+- Faker.js integration
+- Easy setup for testing workflows
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,435 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const schema_1 = require("./schema");
+const server_1 = require("./server");
+const args = process.argv.slice(2);
+const GENERATED_SPEC_RELATIVE_PATH = "fexapi/generated.api.json";
+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 [--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("  fexapi generate");
+    console.log("  fexapi serve");
+};
+const findClosestPackageJson = (startDirectory) => {
+    let currentDirectory = startDirectory;
+    while (true) {
+        const candidate = (0, node_path_1.join)(currentDirectory, "package.json");
+        if ((0, node_fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+        const parentDirectory = (0, node_path_1.dirname)(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            return undefined;
+        }
+        currentDirectory = parentDirectory;
+    }
+};
+const readDependencyNames = (packageJsonPath) => {
+    const packageJsonText = (0, node_fs_1.readFileSync)(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonText);
+    const dependencies = (packageJson.dependencies ?? {});
+    const devDependencies = (packageJson.devDependencies ?? {});
+    return new Set([
+        ...Object.keys(dependencies),
+        ...Object.keys(devDependencies),
+    ]);
+};
+const readWorkspaceDependencyNames = (projectRoot) => {
+    const result = new Set();
+    const rootsToScan = [
+        (0, node_path_1.join)(projectRoot, "apps"),
+        (0, node_path_1.join)(projectRoot, "packages"),
+    ];
+    for (const rootPath of rootsToScan) {
+        if (!(0, node_fs_1.existsSync)(rootPath)) {
+            continue;
+        }
+        for (const entry of (0, node_fs_1.readdirSync)(rootPath)) {
+            const entryPath = (0, node_path_1.join)(rootPath, entry);
+            if (!(0, node_fs_1.statSync)(entryPath).isDirectory()) {
+                continue;
+            }
+            const packageJsonPath = (0, node_path_1.join)(entryPath, "package.json");
+            if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+                continue;
+            }
+            const dependencyNames = readDependencyNames(packageJsonPath);
+            for (const dependencyName of dependencyNames) {
+                result.add(dependencyName);
+            }
+        }
+    }
+    return result;
+};
+const detectProject = (packageJsonPath, projectRoot) => {
+    const dependencyNames = readDependencyNames(packageJsonPath);
+    const frameworks = new Set();
+    const tooling = new Set();
+    if (dependencyNames.has("turbo") ||
+        (0, node_fs_1.existsSync)((0, node_path_1.join)(projectRoot, "turbo.json"))) {
+        tooling.add("turborepo");
+    }
+    if (dependencyNames.has("nx") || (0, node_fs_1.existsSync)((0, node_path_1.join)(projectRoot, "nx.json"))) {
+        tooling.add("nx");
+    }
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(projectRoot, "pnpm-workspace.yaml"))) {
+        tooling.add("pnpm-workspace");
+    }
+    if (tooling.has("turborepo") || tooling.has("pnpm-workspace")) {
+        const workspaceDeps = readWorkspaceDependencyNames(projectRoot);
+        for (const dependencyName of workspaceDeps) {
+            dependencyNames.add(dependencyName);
+        }
+    }
+    if (dependencyNames.has("next")) {
+        frameworks.add("nextjs");
+    }
+    if (dependencyNames.has("react") || dependencyNames.has("react-dom")) {
+        frameworks.add("reactjs");
+    }
+    if (dependencyNames.has("vue")) {
+        frameworks.add("vue");
+    }
+    if (dependencyNames.has("nuxt")) {
+        frameworks.add("nuxt");
+    }
+    if (dependencyNames.has("svelte")) {
+        frameworks.add("svelte");
+    }
+    if (dependencyNames.has("@sveltejs/kit")) {
+        frameworks.add("sveltekit");
+    }
+    if (dependencyNames.has("@angular/core")) {
+        frameworks.add("angular");
+    }
+    if (dependencyNames.has("solid-js")) {
+        frameworks.add("solid");
+    }
+    if (dependencyNames.has("@remix-run/react") ||
+        dependencyNames.has("@remix-run/node")) {
+        frameworks.add("remix");
+    }
+    if (dependencyNames.has("astro")) {
+        frameworks.add("astro");
+    }
+    if (dependencyNames.has("vite")) {
+        tooling.add("vite");
+    }
+    const frameworkList = Array.from(frameworks);
+    const primaryFramework = frameworkList[0] ?? "unknown";
+    return {
+        primaryFramework,
+        frameworks: frameworkList.length > 0 ? frameworkList : ["unknown"],
+        tooling: Array.from(tooling),
+    };
+};
+const getSchemaTemplate = (framework) => {
+    const frameworkHint = framework === "nextjs"
+        ? "# Framework: Next.js"
+        : framework === "reactjs"
+            ? "# Framework: React"
+            : "# Framework: unknown";
+    return [
+        frameworkHint,
+        "# Server",
+        "port: 4000",
+        "",
+        "# Routes",
+        "# Format: METHOD /endpoint: field:type,field:type",
+        "GET /users: id:uuid,fullName:name,username:string,email:email,avatarUrl:url",
+        "GET /posts: id:uuid,title:string,body:string,createdAt:date",
+    ].join("\n");
+};
+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") };
+};
+const parseGenerateOptions = (generateArgs) => {
+    const invalidFlags = generateArgs.filter((value) => value.startsWith("-"));
+    if (invalidFlags.length > 0) {
+        return { error: `Unknown option(s): ${invalidFlags.join(", ")}` };
+    }
+    return {};
+};
+const resolveProjectRoot = () => {
+    const packageJsonPath = findClosestPackageJson(process.cwd());
+    if (!packageJsonPath) {
+        return undefined;
+    }
+    return (0, node_path_1.dirname)(packageJsonPath);
+};
+const initializeProject = ({ force }) => {
+    const packageJsonPath = 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 = 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: 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, `${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;
+};
+const generateFromSchema = () => {
+    const projectRoot = 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 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.writeFileSync)(generatedPath, `${JSON.stringify(generated, 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: 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(`Routes generated: ${parsed.schema.routes.length}`);
+    console.log(`Configured server port: ${parsed.schema.port}`);
+    return 0;
+};
+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 };
+};
+const loadGeneratedApiSpec = (projectRoot) => {
+    const generatedPath = (0, node_path_1.join)(projectRoot, 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;
+    }
+};
+const [firstArg, ...restArgs] = args;
+if (firstArg === "init") {
+    if (restArgs.includes("--help") || restArgs.includes("-h")) {
+        console.log("Usage: fexapi init [--force]");
+        console.log("Detects frameworks/tooling and creates fexapi.config.json + fexapi/schema.fexapi.");
+        console.log("Use --force to overwrite existing files.");
+        process.exit(0);
+    }
+    const initOptions = parseInitOptions(restArgs);
+    if ("error" in initOptions) {
+        console.error(initOptions.error);
+        console.log("");
+        console.log("Usage: fexapi init [--force]");
+        process.exit(1);
+    }
+    const exitCode = initializeProject({ force: initOptions.force });
+    process.exit(exitCode);
+}
+else if (firstArg === "generate") {
+    if (restArgs.includes("--help") || restArgs.includes("-h")) {
+        console.log("Usage: fexapi generate");
+        console.log("Reads fexapi/schema.fexapi and creates fexapi/generated.api.json.");
+        process.exit(0);
+    }
+    const generateOptions = parseGenerateOptions(restArgs);
+    if (generateOptions.error) {
+        console.error(generateOptions.error);
+        console.log("");
+        console.log("Usage: fexapi generate");
+        process.exit(1);
+    }
+    const exitCode = generateFromSchema();
+    process.exit(exitCode);
+}
+else if (!firstArg || firstArg === "serve" || firstArg.startsWith("-")) {
+    const serveArgs = firstArg === "serve" ? restArgs : args;
+    if (serveArgs.includes("--help") || serveArgs.includes("-h")) {
+        printHelp();
+        process.exit(0);
+    }
+    const options = parseServeOptions(serveArgs);
+    if ("error" in options) {
+        console.error(options.error);
+        console.log("");
+        printHelp();
+        process.exit(1);
+    }
+    const projectRoot = resolveProjectRoot();
+    const generatedSpec = projectRoot
+        ? loadGeneratedApiSpec(projectRoot)
+        : undefined;
+    const effectivePort = options.port ?? generatedSpec?.port ?? 4000;
+    if (generatedSpec) {
+        console.log(`Using generated schema routes (${generatedSpec.routes.length}) from ${GENERATED_SPEC_RELATIVE_PATH}`);
+    }
+    else {
+        console.log("No generated schema found. Run `fexapi generate` to serve schema-defined endpoints.");
+    }
+    const server = (0, server_1.startServer)({
+        host: options.host,
+        port: effectivePort,
+        apiSpec: generatedSpec,
+    });
+    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);
+}
+else if (firstArg === "help") {
+    printHelp();
+    process.exit(0);
+}
+else {
+    console.error(`Unknown command: ${firstArg}`);
+    console.log("");
+    printHelp();
+    process.exit(1);
+}

package/dist/schema.d.ts

@@ -0,0 +1,19 @@
+export type FexapiFieldType = "number" | "string" | "boolean" | "date" | "uuid" | "email" | "url" | "name" | "phone";
+export type FexapiField = {
+    name: string;
+    type: FexapiFieldType;
+};
+export type FexapiRoute = {
+    method: string;
+    path: string;
+    fields: FexapiField[];
+};
+export type FexapiSchema = {
+    port: number;
+    routes: FexapiRoute[];
+};
+export declare const parseFexapiSchema: (schemaText: string) => {
+    schema?: FexapiSchema;
+    errors: string[];
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,MAAM,GACN,MAAM,GACN,OAAO,GACP,KAAK,GACL,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB,CAAC;AAkGF,eAAO,MAAM,iBAAiB,GAC5B,YAAY,MAAM,KACjB;IAAE,MAAM,CAAC,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAoD3C,CAAC"}

package/dist/schema.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFexapiSchema = void 0;
+const VALID_TYPES = [
+    "number",
+    "string",
+    "boolean",
+    "date",
+    "uuid",
+    "email",
+    "url",
+    "name",
+    "phone",
+];
+const DEFAULT_PORT = 4000;
+const parseField = (rawField) => {
+    const [rawName, rawType] = rawField.split(":");
+    const name = rawName?.trim();
+    const type = rawType?.trim().toLowerCase();
+    if (!name) {
+        return { error: `Invalid field "${rawField}". Missing field name.` };
+    }
+    if (!type) {
+        return { error: `Invalid field "${rawField}". Missing field type.` };
+    }
+    if (!VALID_TYPES.includes(type)) {
+        return {
+            error: `Unknown type "${type}" in field "${name}". Valid types: ${VALID_TYPES.join(", ")}`,
+        };
+    }
+    return {
+        name,
+        type: type,
+    };
+};
+const parseRoute = (line) => {
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex === -1) {
+        return {
+            error: "Invalid route definition. Expected format: METHOD /endpoint: field:type,field:type",
+        };
+    }
+    const rawLeft = line.slice(0, separatorIndex);
+    const rawFields = line.slice(separatorIndex + 1);
+    if (!rawLeft || !rawFields) {
+        return {
+            error: "Invalid route definition. Expected format: METHOD /endpoint: field:type,field:type",
+        };
+    }
+    const [rawMethod, rawPath] = rawLeft.trim().split(/\s+/, 2);
+    const method = rawMethod?.toUpperCase();
+    const path = rawPath?.trim();
+    if (!method || !path) {
+        return {
+            error: "Invalid route definition. Missing METHOD or /endpoint before ':'.",
+        };
+    }
+    if (!path.startsWith("/")) {
+        return { error: `Route path must start with '/': ${path}` };
+    }
+    const fields = [];
+    for (const part of rawFields.split(",")) {
+        const trimmedPart = part.trim();
+        if (!trimmedPart) {
+            continue;
+        }
+        const parsedField = parseField(trimmedPart);
+        if ("error" in parsedField) {
+            return { error: parsedField.error };
+        }
+        fields.push(parsedField);
+    }
+    if (fields.length === 0) {
+        return { error: `Route ${method} ${path} has no valid fields.` };
+    }
+    return { method, path, fields };
+};
+const parseFexapiSchema = (schemaText) => {
+    let port = DEFAULT_PORT;
+    const routes = [];
+    const errors = [];
+    const lines = schemaText
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#"));
+    for (const line of lines) {
+        if (line.toLowerCase().startsWith("port:")) {
+            const rawPort = line.slice(line.indexOf(":") + 1).trim();
+            const parsedPort = Number(rawPort);
+            if (!Number.isInteger(parsedPort) ||
+                parsedPort < 1 ||
+                parsedPort > 65535) {
+                errors.push(`Invalid port value: ${rawPort}`);
+            }
+            else {
+                port = parsedPort;
+            }
+            continue;
+        }
+        const parsedRoute = parseRoute(line);
+        if ("error" in parsedRoute) {
+            errors.push(parsedRoute.error);
+            continue;
+        }
+        routes.push(parsedRoute);
+    }
+    if (routes.length === 0) {
+        errors.push("No routes defined in schema.fexapi.");
+    }
+    if (errors.length > 0) {
+        return { errors };
+    }
+    return {
+        schema: {
+            port,
+            routes,
+        },
+        errors: [],
+    };
+};
+exports.parseFexapiSchema = parseFexapiSchema;

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import type { ServerResponse } from "node:http";
+import type { FexapiRoute } from "./schema";
+export type ServerOptions = {
+    host?: string;
+    port?: number;
+    apiSpec?: GeneratedApiSpec;
+};
+export type GeneratedApiSpec = {
+    port: number;
+    routes: FexapiRoute[];
+};
+export declare const startServer: ({ host, port, apiSpec, }?: ServerOptions) => import("http").Server<typeof import("http").IncomingMessage, typeof ServerResponse>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB,CAAC;AA2FF,eAAO,MAAM,WAAW,GAAI,2BAIzB,aAAkB,wFA8DpB,CAAC"}

package/dist/server.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = void 0;
+const faker_1 = require("@faker-js/faker");
+const node_http_1 = require("node:http");
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 4000;
+const sendJson = (response, statusCode, payload) => {
+    response.writeHead(statusCode, { "Content-Type": "application/json" });
+    response.end(JSON.stringify(payload));
+};
+const createValueFromField = (field) => {
+    switch (field.type) {
+        case "number":
+            return faker_1.faker.number.int({ min: 1, max: 10000 });
+        case "string":
+            return faker_1.faker.lorem.words({ min: 1, max: 4 });
+        case "boolean":
+            return faker_1.faker.datatype.boolean();
+        case "date":
+            return faker_1.faker.date.recent({ days: 30 }).toISOString();
+        case "uuid":
+            return faker_1.faker.string.uuid();
+        case "email":
+            return faker_1.faker.internet.email();
+        case "url":
+            return faker_1.faker.internet.url();
+        case "name":
+            return faker_1.faker.person.fullName();
+        case "phone":
+            return faker_1.faker.phone.number();
+        default:
+            return faker_1.faker.lorem.word();
+    }
+};
+const createRecordFromRoute = (route) => {
+    return route.fields.reduce((record, field) => {
+        record[field.name] = createValueFromField(field);
+        return record;
+    }, {});
+};
+const toCollectionKey = (routePath) => {
+    const segments = routePath.split("/").filter(Boolean);
+    const lastSegment = segments[segments.length - 1];
+    if (!lastSegment) {
+        return "data";
+    }
+    return lastSegment.replace(/[^a-zA-Z0-9_]/g, "_");
+};
+const createMockUser = () => {
+    return {
+        id: faker_1.faker.string.uuid(),
+        fullName: faker_1.faker.person.fullName(),
+        username: faker_1.faker.internet.username(),
+        email: faker_1.faker.internet.email(),
+        avatarUrl: faker_1.faker.image.avatar(),
+    };
+};
+const createMockPost = () => {
+    return {
+        id: faker_1.faker.string.uuid(),
+        title: faker_1.faker.lorem.sentence(),
+        body: faker_1.faker.lorem.paragraphs({ min: 1, max: 3 }),
+        createdAt: faker_1.faker.date.recent({ days: 14 }).toISOString(),
+    };
+};
+const getCountFromUrl = (urlText, fallback = 5) => {
+    if (!urlText) {
+        return fallback;
+    }
+    const url = new URL(urlText, "http://localhost");
+    const rawCount = Number(url.searchParams.get("count") ?? fallback);
+    if (!Number.isFinite(rawCount)) {
+        return fallback;
+    }
+    return Math.min(Math.max(Math.floor(rawCount), 1), 50);
+};
+const startServer = ({ host = DEFAULT_HOST, port = DEFAULT_PORT, apiSpec, } = {}) => {
+    const server = (0, node_http_1.createServer)((request, response) => {
+        const pathname = new URL(request.url ?? "/", "http://localhost").pathname;
+        if (request.method === "GET" && pathname === "/health") {
+            sendJson(response, 200, {
+                ok: true,
+                timestamp: new Date().toISOString(),
+            });
+            return;
+        }
+        if (apiSpec) {
+            const matchedRoute = apiSpec.routes.find((route) => route.method === request.method && route.path === pathname);
+            if (matchedRoute) {
+                const count = getCountFromUrl(request.url, 5);
+                const payloadKey = toCollectionKey(matchedRoute.path);
+                sendJson(response, 200, {
+                    [payloadKey]: Array.from({ length: count }, () => createRecordFromRoute(matchedRoute)),
+                });
+                return;
+            }
+        }
+        if (request.method === "GET" && pathname === "/users") {
+            const count = getCountFromUrl(request.url, 8);
+            sendJson(response, 200, {
+                users: Array.from({ length: count }, createMockUser),
+            });
+            return;
+        }
+        if (request.method === "GET" && pathname === "/posts") {
+            const count = getCountFromUrl(request.url, 5);
+            sendJson(response, 200, {
+                posts: Array.from({ length: count }, createMockPost),
+            });
+            return;
+        }
+        sendJson(response, 404, {
+            message: "Route not found",
+            availableRoutes: apiSpec
+                ? [
+                    "GET /health",
+                    ...apiSpec.routes.map((route) => `${route.method} ${route.path}`),
+                ]
+                : ["GET /health", "GET /users?count=10", "GET /posts?count=5"],
+        });
+    });
+    server.listen(port, host, () => {
+        console.log(`Mock API running at http://${host}:${port}`);
+    });
+    return server;
+};
+exports.startServer = startServer;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "fexapi",
+  "version": "0.1.0",
+  "description": "Mock API generation CLI tool for local development and testing",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "fexapi": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check-types": "tsc --noEmit",
+    "start": "node dist/index.js",
+    "dev": "tsc -w -p tsconfig.json",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "mock",
+    "api",
+    "cli",
+    "testing",
+    "development",
+    "faker",
+    "mock-server"
+  ],
+  "author": "Shreeteja Mutukundu smutukundu2006@gmail.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shreeteja172/fexapi.git",
+    "directory": "apps/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/shreeteja172/fexapi/issues"
+  },
+  "homepage": "https://github.com/shreeteja172/fexapi#readme",
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "typescript": "5.9.2"
+  },
+  "dependencies": {
+    "@faker-js/faker": "^10.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}