mock-config-server 4.0.3 → 5.0.0-beta.0

package/dist/bin/templates/ts/rest/mock-server.config.ts

@@ -1,16 +1,16 @@
-import type { FlatMockServerConfig } from 'mock-config-server';
-
-import { getUserRequest, getUsersRequest, postUserRequest } from './mock-requests';
-
-const mockServerConfig: FlatMockServerConfig = [
-  {
-    port: 31299,
-    baseUrl: '/'
-  },
-  {
-    name: 'rest',
-    configs: [getUserRequest, getUsersRequest, postUserRequest]
-  }
-];
-
-export default mockServerConfig;
+import type { MockServerConfig } from 'mock-config-server';
+
+import { getUserRequest, getUsersRequest, postUserRequest } from './mock-requests';
+
+const mockServerConfig: MockServerConfig = [
+  {
+    port: 31299,
+    baseUrl: '/'
+  },
+  {
+    name: 'rest',
+    configs: [getUserRequest, getUsersRequest, postUserRequest]
+  }
+];
+
+export default mockServerConfig;

package/dist/src/core/database/createDatabaseRoutes/helpers/search/search.js

@@ -5,14 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    search: function() {
+    get search () {
         return search;
     },
-    searchInNestedObjects: function() {
+    get searchInNestedObjects () {
         return searchInNestedObjects;
     }
 });

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileStorage.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "FileStorage", {
         return FileStorage;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _constants = require("../../../../../utils/constants");
 const _helpers = require("../../helpers");
 const _FileWriter = require("./FileWriter");
@@ -22,9 +22,9 @@ class FileStorage {
     fileWriter;
     data;
     constructor(fileName){
-        const filePath = _nodepath.default.resolve(_constants.APP_PATH, fileName);
+        const filePath = _path.default.resolve(_constants.APP_PATH, fileName);
         this.fileWriter = new _FileWriter.FileWriter(filePath);
-        this.data = JSON.parse(_nodefs.default.readFileSync(filePath, 'utf-8'));
+        this.data = JSON.parse(_fs.default.readFileSync(filePath, 'utf-8'));
     }
     read(key) {
         if (!key) return this.data;

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileWriter.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "FileWriter", {
         return FileWriter;
     }
 });
-const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -38,7 +38,7 @@ class FileWriter {
     }
     async unlockedWrite(data, recursionLevel = 0) {
         this.writeIsLocked = true;
-        await _nodefs.default.promises.writeFile(this.filePath, data, 'utf-8');
+        await _fs.default.promises.writeFile(this.filePath, data, 'utf-8');
         this.writeIsLocked = false;
         // ✅ important:
         // copy content of this.nextData into new variable

package/dist/src/core/functions/graphql/graphql.d.ts

@@ -0,0 +1,54 @@
+import type { Data, GraphQLEntitiesByEntityName, GraphQLOperationName, GraphQLOperationType, GraphQLParams, GraphQLRequestConfig, GraphQLSettings } from '../../../utils/types';
+interface GraphQLRequestInput {
+    body?: unknown;
+    params?: unknown;
+    query?: unknown;
+    response?: Data;
+}
+type ReservedGraphQLConfigKeys = {
+    [K in 'handler' | 'match' | 'queue' | 'response']?: never;
+};
+type GraphQLInlineResponse<Response> = Response extends Record<string, unknown> ? Response & ReservedGraphQLConfigKeys : Response;
+type GraphQLFunction<Options extends GraphQLRequestInput> = (params: GraphQLParams<Options['query'], Options['body'], Options['params'], Options['response']>) => Options['response'] | Promise<Options['response']>;
+interface GraphQLResponseObject<Response> {
+    match?: GraphQLEntitiesByEntityName;
+    response: Response;
+}
+interface GraphQLHandlerObject<Options extends GraphQLRequestInput> {
+    handler: GraphQLFunction<Options>;
+    match?: GraphQLEntitiesByEntityName;
+}
+interface GraphQLQueueObject<Options extends GraphQLRequestInput> {
+    match?: GraphQLEntitiesByEntityName;
+    queue: Array<{
+        handler: GraphQLFunction<Options>;
+        time?: number;
+    } | {
+        response: Options['response'];
+        time?: number;
+    }>;
+}
+export declare const graphql: {
+    query: {
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLResponseObject<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLHandlerObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLFunction<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLQueueObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLInlineResponse<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+    };
+    mutation: {
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLResponseObject<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLHandlerObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLFunction<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLQueueObject<Options>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: GraphQLOperationName, config: GraphQLInlineResponse<Options["response"]>, settings?: GraphQLSettings, operationType?: undefined): GraphQLRequestConfig;
+    };
+    raw: {
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLResponseObject<Options["response"]>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLHandlerObject<Options>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLFunction<Options>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLQueueObject<Options>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+        <Options extends GraphQLRequestInput = Partial<GraphQLRequestInput>>(identifier: string, config: GraphQLInlineResponse<Options["response"]>, settings?: GraphQLSettings, operationType?: GraphQLOperationType | undefined): GraphQLRequestConfig;
+    };
+};
+export {};

package/dist/src/core/functions/graphql/graphql.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "graphql", {
+    enumerable: true,
+    get: function() {
+        return graphql;
+    }
+});
+const _helpers = require("./helpers");
+const resolveConfigType = (config)=>{
+    if (typeof config === 'function') return {
+        type: 'inlineHandler',
+        config
+    };
+    if (typeof config !== 'object' || config === null) return {
+        type: 'inlineResponse',
+        config
+    };
+    if ('queue' in config) return {
+        type: 'queue',
+        config
+    };
+    if ('response' in config) return {
+        type: 'data',
+        config
+    };
+    if ('handler' in config) return {
+        type: 'handlerObj',
+        config
+    };
+    return {
+        type: 'inlineResponse',
+        config
+    };
+};
+const createConfigResolver = (config, settings = {})=>{
+    const resolvedConfig = resolveConfigType(config);
+    switch(resolvedConfig.type){
+        case 'inlineResponse':
+            return {
+                data: resolvedConfig.config,
+                entities: {},
+                settings
+            };
+        case 'data':
+            {
+                var _resolvedConfig_config_match;
+                return {
+                    data: resolvedConfig.config.response,
+                    entities: (_resolvedConfig_config_match = resolvedConfig.config.match) !== null && _resolvedConfig_config_match !== void 0 ? _resolvedConfig_config_match : {},
+                    settings
+                };
+            }
+        case 'queue':
+            {
+                const normalizedQueue = resolvedConfig.config.queue.map((item)=>{
+                    if ('handler' in item) {
+                        return {
+                            data: item.handler,
+                            time: item.time
+                        };
+                    }
+                    if ('response' in item) {
+                        return {
+                            data: item.response,
+                            time: item.time
+                        };
+                    }
+                    throw new Error(`Unexpected queue item kind: ${JSON.stringify(item, null, 2)}`);
+                });
+                var _resolvedConfig_config_match1;
+                return {
+                    data: (0, _helpers.createQueueHandler)(normalizedQueue),
+                    entities: (_resolvedConfig_config_match1 = resolvedConfig.config.match) !== null && _resolvedConfig_config_match1 !== void 0 ? _resolvedConfig_config_match1 : {},
+                    settings
+                };
+            }
+        case 'inlineHandler':
+            return {
+                data: resolvedConfig.config,
+                entities: {},
+                settings
+            };
+        case 'handlerObj':
+            {
+                var _resolvedConfig_config_match2;
+                return {
+                    data: resolvedConfig.config.handler,
+                    entities: (_resolvedConfig_config_match2 = resolvedConfig.config.match) !== null && _resolvedConfig_config_match2 !== void 0 ? _resolvedConfig_config_match2 : {},
+                    settings
+                };
+            }
+        default:
+            {
+                throw new Error(`Unexpected route config kind: ${JSON.stringify(config, null, 2)}`);
+            }
+    }
+};
+const createGraphQLFactory = (mode)=>{
+    function createRequestConfig(identifier, config, settings, operationType) {
+        if (mode === 'raw') {
+            return {
+                query: identifier,
+                operationType: operationType !== null && operationType !== void 0 ? operationType : 'query',
+                routes: [
+                    createConfigResolver(config, settings)
+                ]
+            };
+        }
+        return {
+            operationName: identifier,
+            operationType: mode,
+            routes: [
+                createConfigResolver(config, settings)
+            ]
+        };
+    }
+    return createRequestConfig;
+};
+const graphql = {
+    query: createGraphQLFactory('query'),
+    mutation: createGraphQLFactory('mutation'),
+    raw: createGraphQLFactory('raw')
+};

package/dist/src/core/functions/graphql/helpers/createQueueHandler/createQueueHandler.d.ts

@@ -0,0 +1,5 @@
+import type { GraphqlDataResponse, GraphqlDataResponseFunction } from '../../../../../utils/types';
+export declare const createQueueHandler: (normalizedQueue: {
+    data: GraphqlDataResponse;
+    time?: number;
+}[]) => GraphqlDataResponseFunction;

package/dist/src/core/functions/graphql/helpers/createQueueHandler/createQueueHandler.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createQueueHandler", {
+    enumerable: true,
+    get: function() {
+        return createQueueHandler;
+    }
+});
+const createQueueHandler = (normalizedQueue)=>{
+    let queueIndex = 0;
+    let timeoutInProgress = false;
+    const updateQueueIndex = ()=>{
+        queueIndex = normalizedQueue.length - 1 === queueIndex ? 0 : queueIndex + 1;
+    };
+    return async (params)=>{
+        if (!normalizedQueue.length) {
+            return params.next();
+        }
+        const queueItem = normalizedQueue[queueIndex];
+        const { time } = queueItem;
+        if (time && !timeoutInProgress) {
+            timeoutInProgress = true;
+            setTimeout(()=>{
+                timeoutInProgress = false;
+                updateQueueIndex();
+            }, time);
+        }
+        if (!time) {
+            updateQueueIndex();
+        }
+        return typeof queueItem.data === 'function' ? queueItem.data(params) : queueItem.data;
+    };
+};

package/dist/src/core/functions/graphql/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './createQueueHandler/createQueueHandler';

package/dist/src/core/{rest/createRestRoutes → functions/graphql}/helpers/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./prepareRestRequestConfigs/prepareRestRequestConfigs"), exports);
+_export_star(require("./createQueueHandler/createQueueHandler"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/src/core/functions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './graphql/graphql';
+export * from './mock';
+export * from './rest/rest';

package/dist/src/core/functions/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./graphql/graphql"), exports);
+_export_star(require("./mock"), exports);
+_export_star(require("./rest/rest"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/src/core/functions/mock.d.ts

@@ -0,0 +1,2 @@
+import type { MockServerConfig } from '../../utils/types';
+export declare const mock: (...config: MockServerConfig) => MockServerConfig;

package/dist/src/core/functions/mock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mock", {
+    enumerable: true,
+    get: function() {
+        return mock;
+    }
+});
+const mock = (...config)=>config;

package/dist/src/core/functions/rest/helpers/createFileHandler/createFileHandler.d.ts

@@ -0,0 +1,2 @@
+import type { RestDataResponseFunction, RestFileResponse, RestMethod } from '../../../../../utils/types';
+export declare const createFileHandler: <Method extends RestMethod>(filePath: RestFileResponse) => RestDataResponseFunction<Method>;

package/dist/src/core/functions/rest/helpers/createFileHandler/createFileHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createFileHandler", {
+    enumerable: true,
+    get: function() {
+        return createFileHandler;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _helpers = require("../../../../../utils/helpers");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const createFileHandler = (filePath)=>({ response, setHeader, next })=>{
+        if (!(0, _helpers.isFilePathValid)(filePath)) {
+            return next();
+        }
+        const buffer = _fs.default.readFileSync(_path.default.resolve(filePath));
+        const fileName = filePath.replaceAll('\\', '/').split('/').at(-1);
+        const fileExtension = fileName.split('.').at(-1);
+        response.type(fileExtension);
+        setHeader('Content-Disposition', `attachment; filename="${fileName}"`);
+        return buffer;
+    };

package/dist/src/core/functions/rest/helpers/createQueueHandler/createQueueHandler.d.ts

@@ -0,0 +1,5 @@
+import type { RestDataResponse, RestDataResponseFunction, RestMethod } from '../../../../../utils/types';
+export declare const createQueueHandler: <Method extends RestMethod>(queue: {
+    data: RestDataResponse<Method>;
+    time?: number;
+}[]) => RestDataResponseFunction<Method>;

package/dist/src/core/functions/rest/helpers/createQueueHandler/createQueueHandler.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createQueueHandler", {
+    enumerable: true,
+    get: function() {
+        return createQueueHandler;
+    }
+});
+const createQueueHandler = (queue)=>{
+    let queueIndex = 0;
+    let timeoutInProgress = false;
+    const updateQueueIndex = ()=>{
+        queueIndex = queue.length - 1 === queueIndex ? 0 : queueIndex + 1;
+    };
+    return async (params)=>{
+        if (!queue.length) {
+            return params.next();
+        }
+        const queueItem = queue[queueIndex];
+        const { time } = queueItem;
+        if (time && !timeoutInProgress) {
+            timeoutInProgress = true;
+            setTimeout(()=>{
+                timeoutInProgress = false;
+                updateQueueIndex();
+            }, time);
+        }
+        if (!time) {
+            updateQueueIndex();
+        }
+        return typeof queueItem.data === 'function' ? queueItem.data(params) : queueItem.data;
+    };
+};

package/dist/src/core/functions/rest/helpers/formatSsePayload/formatSsePayload.d.ts

@@ -0,0 +1,5 @@
+export declare const formatSsePayload: (data: string, meta?: {
+    event?: string;
+    id?: string;
+    retry?: number;
+}) => string;

package/dist/src/core/functions/rest/helpers/formatSsePayload/formatSsePayload.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatSsePayload", {
+    enumerable: true,
+    get: function() {
+        return formatSsePayload;
+    }
+});
+const _zod = /*#__PURE__*/ _interop_require_default(require("zod"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const sseMetaSchema = _zod.default.object({
+    event: _zod.default.string().optional(),
+    id: _zod.default.string().optional(),
+    retry: _zod.default.number().int().nonnegative().optional()
+}).optional();
+// ✅ important:
+// SSE is a line-based protocol. `id` and `event` must be single-line values.
+// Strip CR/LF so metadata cannot break frame structure.
+const normalizeSseMetaValue = (value)=>value.replaceAll('\r', '').replaceAll('\n', '');
+const formatSsePayload = (data, meta)=>{
+    const parseMetaResult = sseMetaSchema.safeParse(meta);
+    if (!parseMetaResult.success) {
+        var _parseMetaResult_error_issues_;
+        throw new Error(`Invalid SSE meta: ${(_parseMetaResult_error_issues_ = parseMetaResult.error.issues[0]) === null || _parseMetaResult_error_issues_ === void 0 ? void 0 : _parseMetaResult_error_issues_.message}`);
+    }
+    const parsedMeta = parseMetaResult.data;
+    const lines = [];
+    if (parsedMeta === null || parsedMeta === void 0 ? void 0 : parsedMeta.id) {
+        lines.push(`id: ${normalizeSseMetaValue(parsedMeta.id)}`);
+    }
+    if (parsedMeta === null || parsedMeta === void 0 ? void 0 : parsedMeta.event) {
+        lines.push(`event: ${normalizeSseMetaValue(parsedMeta.event)}`);
+    }
+    if ((parsedMeta === null || parsedMeta === void 0 ? void 0 : parsedMeta.retry) != null) {
+        lines.push(`retry: ${parsedMeta.retry}`);
+    }
+    // ✅ important:
+    // Multiline payloads are encoded as multiple `data:` lines.
+    // SSE clients concatenate consecutive `data:` lines with '\n' into one message.
+    data.split(/\r\n|\r|\n/).forEach((line)=>{
+        lines.push(`data: ${line}`);
+    });
+    return `${lines.join('\n')}\n\n`;
+};

package/dist/src/core/functions/rest/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './createFileHandler/createFileHandler';
+export * from './createQueueHandler/createQueueHandler';
+export * from './formatSsePayload/formatSsePayload';

package/dist/src/core/functions/rest/helpers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createFileHandler/createFileHandler"), exports);
+_export_star(require("./createQueueHandler/createQueueHandler"), exports);
+_export_star(require("./formatSsePayload/formatSsePayload"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/src/core/functions/rest/index.d.ts

@@ -0,0 +1 @@
+export * from './rest';

package/dist/src/core/{graphql/createGraphQLRoutes/helpers → functions/rest}/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./prepareGraphQLRequestConfigs/prepareGraphQLRequestConfigs"), exports);
+_export_star(require("./rest"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {