fexapi 0.1.0 → 0.1.2

package/dist/commands/init.js

@@ -0,0 +1,250 @@
+"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 promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const constants_1 = require("../constants");
+const detect_1 = require("../project/detect");
+const paths_1 = require("../project/paths");
+const DEFAULT_INIT_PORT = 3000;
+const parseYesNo = (value, defaultValue) => {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+        return defaultValue;
+    }
+    if (normalized === "y" || normalized === "yes") {
+        return true;
+    }
+    if (normalized === "n" || normalized === "no") {
+        return false;
+    }
+    return undefined;
+};
+const askInitWizardQuestions = async () => {
+    if (!node_process_1.stdin.isTTY || !node_process_1.stdout.isTTY) {
+        return {
+            port: DEFAULT_INIT_PORT,
+            cors: true,
+            generateSampleSchemas: true,
+        };
+    }
+    const questionInterface = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        let port = DEFAULT_INIT_PORT;
+        while (true) {
+            const answer = await questionInterface.question(`What port? (default: ${DEFAULT_INIT_PORT}) `);
+            if (!answer.trim()) {
+                break;
+            }
+            const parsedPort = Number(answer.trim());
+            if (Number.isInteger(parsedPort) &&
+                parsedPort >= 1 &&
+                parsedPort <= 65535) {
+                port = parsedPort;
+                break;
+            }
+            console.log("Please enter a valid port (1-65535).\n");
+        }
+        let cors = true;
+        while (true) {
+            const answer = await questionInterface.question("Enable CORS? (Y/n) ");
+            const parsed = parseYesNo(answer, true);
+            if (parsed !== undefined) {
+                cors = parsed;
+                break;
+            }
+            console.log("Please answer with Y/Yes or N/No.\n");
+        }
+        let generateSampleSchemas = true;
+        while (true) {
+            const answer = await questionInterface.question("Generate sample schemas? (Y/n) ");
+            const parsed = parseYesNo(answer, true);
+            if (parsed !== undefined) {
+                generateSampleSchemas = parsed;
+                break;
+            }
+            console.log("Please answer with Y/Yes or N/No.\n");
+        }
+        console.log("");
+        return {
+            port,
+            cors,
+            generateSampleSchemas,
+        };
+    }
+    finally {
+        questionInterface.close();
+    }
+};
+const getRuntimeConfigTemplate = ({ port, cors, includeSampleRoutes, }) => {
+    const routeSection = includeSampleRoutes
+        ? [
+            "  routes: {",
+            '    "/users": { count: 25, schema: "user" },',
+            '    "/posts": { count: 40, schema: "post" },',
+            "  },",
+        ]
+        : [];
+    return [
+        "module.exports = {",
+        `  port: ${port},`,
+        `  cors: ${cors},`,
+        "  delay: 0,",
+        ...routeSection,
+        "};",
+    ].join("\n");
+};
+const SAMPLE_USER_SCHEMA = [
+    "id:",
+    "  type: uuid",
+    "fullName:",
+    "  type: name",
+    "  faker: person.fullName",
+    "email:",
+    "  type: email",
+    "  faker: internet.email",
+    "avatarUrl:",
+    "  type: url",
+    "  faker: image.avatar",
+].join("\n");
+const SAMPLE_POST_SCHEMA = [
+    "id:",
+    "  type: uuid",
+    "title:",
+    "  type: string",
+    "  faker: lorem.sentence",
+    "body:",
+    "  type: string",
+    "  faker: lorem.paragraph",
+    "createdAt:",
+    "  type: date",
+].join("\n");
+const initializeProject = async ({ 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");
+    const runtimeConfigPath = (0, node_path_1.join)(projectRoot, "fexapi.config.js");
+    const schemasDirectoryPath = (0, node_path_1.join)(projectRoot, "schemas");
+    const userSchemaPath = (0, node_path_1.join)(schemasDirectoryPath, "user.yaml");
+    const postSchemaPath = (0, node_path_1.join)(schemasDirectoryPath, "post.yaml");
+    const wizardAnswers = await askInitWizardQuestions();
+    (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,
+        defaultPort: wizardAnswers.port,
+        corsEnabled: wizardAnswers.cors,
+        sampleSchemasGenerated: wizardAnswers.generateSampleSchemas,
+        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, wizardAnswers.port)}\n`, "utf-8");
+    }
+    const runtimeConfigExists = (0, node_fs_1.existsSync)(runtimeConfigPath);
+    if (!runtimeConfigExists || force) {
+        (0, node_fs_1.writeFileSync)(runtimeConfigPath, `${getRuntimeConfigTemplate({
+            port: wizardAnswers.port,
+            cors: wizardAnswers.cors,
+            includeSampleRoutes: wizardAnswers.generateSampleSchemas,
+        })}\n`, "utf-8");
+    }
+    let userSchemaStatus = "skipped";
+    let postSchemaStatus = "skipped";
+    if (wizardAnswers.generateSampleSchemas) {
+        (0, node_fs_1.mkdirSync)(schemasDirectoryPath, { recursive: true });
+        const userSchemaExists = (0, node_fs_1.existsSync)(userSchemaPath);
+        if (!userSchemaExists || force) {
+            (0, node_fs_1.writeFileSync)(userSchemaPath, `${SAMPLE_USER_SCHEMA}\n`, "utf-8");
+            userSchemaStatus = userSchemaExists ? "overwritten" : "created";
+        }
+        else {
+            userSchemaStatus = "exists";
+        }
+        const postSchemaExists = (0, node_fs_1.existsSync)(postSchemaPath);
+        if (!postSchemaExists || force) {
+            (0, node_fs_1.writeFileSync)(postSchemaPath, `${SAMPLE_POST_SCHEMA}\n`, "utf-8");
+            postSchemaStatus = postSchemaExists ? "overwritten" : "created";
+        }
+        else {
+            postSchemaStatus = "exists";
+        }
+    }
+    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 (runtimeConfigExists && !force) {
+        console.log(`Exists ${runtimeConfigPath}`);
+    }
+    else if (runtimeConfigExists && force) {
+        console.log(`Overwritten ${runtimeConfigPath}`);
+    }
+    else {
+        console.log(`Created ${runtimeConfigPath}`);
+    }
+    if (wizardAnswers.generateSampleSchemas) {
+        if (userSchemaStatus === "exists") {
+            console.log(`Exists ${userSchemaPath}`);
+        }
+        else if (userSchemaStatus === "overwritten") {
+            console.log(`Overwritten ${userSchemaPath}`);
+        }
+        else if (userSchemaStatus === "created") {
+            console.log(`Created ${userSchemaPath}`);
+        }
+        if (postSchemaStatus === "exists") {
+            console.log(`Exists ${postSchemaPath}`);
+        }
+        else if (postSchemaStatus === "overwritten") {
+            console.log(`Overwritten ${postSchemaPath}`);
+        }
+        else if (postSchemaStatus === "created") {
+            console.log(`Created ${postSchemaPath}`);
+        }
+    }
+    else {
+        console.log("Sample schemas were skipped.");
+    }
+    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,12 @@
+import type { Server } from "node:http";
+export declare const createProjectServer: ({ host, port, logEnabled, }: {
+    host: string;
+    port?: number;
+    logEnabled?: boolean;
+}) => Server | undefined;
+export declare const serveProject: ({ host, port, logEnabled, }: {
+    host: string;
+    port?: number;
+    logEnabled?: boolean;
+}) => 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":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAQxC,eAAO,MAAM,mBAAmB,GAAI,6BAIjC;IACD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,KAAG,MAAM,GAAG,SA2DZ,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,6BAI1B;IACD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,KAAG,MAsBH,CAAC"}

package/dist/commands/serve.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveProject = exports.createProjectServer = 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 createProjectServer = ({ host, port, logEnabled = false, }) => {
+    const projectRoot = (0, paths_1.resolveProjectRoot)();
+    if (!projectRoot) {
+        console.error("Could not find package.json in this directory or parent directories.");
+        return undefined;
+    }
+    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.");
+    }
+    return (0, server_1.startServer)({
+        host,
+        port: effectivePort,
+        apiSpec: generatedSpec,
+        runtimeConfig,
+        schemaDefinitions,
+        logRequests: logEnabled,
+    });
+};
+exports.createProjectServer = createProjectServer;
+const serveProject = ({ host, port, logEnabled, }) => {
+    const server = (0, exports.createProjectServer)({ host, port, logEnabled });
+    if (!server) {
+        return 1;
+    }
+    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"}

package/dist/config/schema-definitions.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSchemaDefinitions = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const yaml_1 = require("yaml");
+const VALID_TYPES = new Set([
+    "number",
+    "string",
+    "boolean",
+    "date",
+    "uuid",
+    "email",
+    "url",
+    "name",
+    "phone",
+]);
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const parseSchemaDefinition = (schemaName, rawValue) => {
+    if (!isRecord(rawValue)) {
+        console.error(`Invalid schemas/${schemaName}.yaml: expected root object of field definitions.`);
+        return undefined;
+    }
+    const result = {};
+    for (const [fieldName, rawFieldConfig] of Object.entries(rawValue)) {
+        if (!isRecord(rawFieldConfig)) {
+            console.error(`Invalid schemas/${schemaName}.yaml field \`${fieldName}\`: expected object with type/faker/min/max.`);
+            continue;
+        }
+        const rawType = rawFieldConfig.type;
+        if (typeof rawType !== "string") {
+            console.error(`Invalid schemas/${schemaName}.yaml field \`${fieldName}\`: missing string \`type\`.`);
+            continue;
+        }
+        const normalizedType = rawType.trim().toLowerCase();
+        if (!VALID_TYPES.has(normalizedType)) {
+            console.error(`Invalid schemas/${schemaName}.yaml field \`${fieldName}\`: unknown type \`${rawType}\`.`);
+            continue;
+        }
+        const minValue = rawFieldConfig.min;
+        const maxValue = rawFieldConfig.max;
+        result[fieldName] = {
+            type: normalizedType,
+            faker: typeof rawFieldConfig.faker === "string"
+                ? rawFieldConfig.faker.trim()
+                : undefined,
+            min: typeof minValue === "number" && Number.isFinite(minValue)
+                ? minValue
+                : undefined,
+            max: typeof maxValue === "number" && Number.isFinite(maxValue)
+                ? maxValue
+                : undefined,
+        };
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+};
+const loadSchemaDefinitions = (projectRoot) => {
+    const schemasDirectoryPath = (0, node_path_1.join)(projectRoot, "schemas");
+    if (!(0, node_fs_1.existsSync)(schemasDirectoryPath)) {
+        return {};
+    }
+    const result = {};
+    for (const entry of (0, node_fs_1.readdirSync)(schemasDirectoryPath)) {
+        const schemaPath = (0, node_path_1.join)(schemasDirectoryPath, entry);
+        if (!(0, node_fs_1.statSync)(schemaPath).isFile()) {
+            continue;
+        }
+        const extension = (0, node_path_1.extname)(entry).toLowerCase();
+        if (extension !== ".yaml" && extension !== ".yml") {
+            continue;
+        }
+        const schemaName = (0, node_path_1.basename)(entry, extension).toLowerCase();
+        try {
+            const source = (0, node_fs_1.readFileSync)(schemaPath, "utf-8");
+            const parsed = (0, yaml_1.parse)(source);
+            const definition = parseSchemaDefinition(schemaName, parsed);
+            if (definition) {
+                result[schemaName] = definition;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Failed to parse ${schemaPath}: ${message}`);
+        }
+    }
+    return result;
+};
+exports.loadSchemaDefinitions = loadSchemaDefinitions;

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const GENERATED_SPEC_RELATIVE_PATH = "fexapi/generated.api.json";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,8BAA8B,CAAC"}

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATED_SPEC_RELATIVE_PATH = void 0;
+exports.GENERATED_SPEC_RELATIVE_PATH = "fexapi/generated.api.json";