mock-config-server 3.7.1 → 4.0.1

package/dist/{bin/validateMockServerConfig → src/utils/validate}/restConfigSchema/restConfigSchema.js

@@ -2,10 +2,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "restConfigSchema", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    restConfigSchema: function() {
         return restConfigSchema;
+    },
+    restRequestConfigSchema: function() {
+        return restRequestConfigSchema;
     }
 });
 const _zod = require("zod");
@@ -22,7 +30,7 @@ const baseRequestConfigSchema = (method)=>_zod.z.strictObject({
         routes: _zod.z.array((0, _routeConfigSchema.routeConfigSchema)(method)),
         interceptors: (0, _utils.plainObjectSchema)(_interceptorsSchema.interceptorsSchema).optional()
     });
-const requestConfigSchema = _zod.z.union([
+const restRequestConfigSchema = _zod.z.union([
     baseRequestConfigSchema('get'),
     baseRequestConfigSchema('post'),
     baseRequestConfigSchema('put'),
@@ -32,6 +40,6 @@ const requestConfigSchema = _zod.z.union([
 ]);
 const restConfigSchema = _zod.z.strictObject({
     baseUrl: _baseUrlSchema.baseUrlSchema.optional(),
-    configs: _zod.z.array(requestConfigSchema),
+    configs: _zod.z.array(restRequestConfigSchema),
     interceptors: (0, _utils.plainObjectSchema)(_interceptorsSchema.interceptorsSchema).optional()
 });

package/dist/{bin/validateMockServerConfig → src/utils/validate}/restConfigSchema/routeConfigSchema/routeConfigSchema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { RestMethod } from '../../../../src/utils/types';
+import type { RestMethod } from '../../../types';
 export declare const routeConfigSchema: (method: RestMethod) => z.ZodUnion<[z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodObject<z.objectUtil.extendShape<{
     settings: z.ZodOptional<z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodTypeAny>>;
     data: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>, z.ZodAny]>;
@@ -48,21 +48,36 @@ export declare const routeConfigSchema: (method: RestMethod) => z.ZodUnion<[z.Zo
         status?: number | undefined;
         delay?: number | undefined;
     }>;
-    queue: z.ZodArray<z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodType<{
+    queue: z.ZodArray<z.ZodUnion<[z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodObject<{
+        time: z.ZodOptional<z.ZodNumber>;
+        data: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>, z.ZodAny]>;
+    }, "strict", z.ZodTypeAny, {
         data?: any;
         time?: number | undefined;
-    }, z.ZodTypeDef, {
+    }, {
         data?: any;
         time?: number | undefined;
-    }>>, "many">;
+    }>>, z.ZodObject<{
+        time: z.ZodOptional<z.ZodNumber>;
+        file: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        file: string;
+        time?: number | undefined;
+    }, {
+        file: string;
+        time?: number | undefined;
+    }>]>, "many">;
 }, {
     entities: z.ZodOptional<z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodTypeAny>>;
     interceptors: z.ZodOptional<z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodTypeAny>>;
 }>, "strict", z.ZodTypeAny, {
-    queue: {
+    queue: ({
         data?: any;
         time?: number | undefined;
-    }[];
+    } | {
+        file: string;
+        time?: number | undefined;
+    })[];
     settings: {
         polling: true;
         status?: number | undefined;

package/dist/{bin/validateMockServerConfig → src/utils/validate}/restConfigSchema/routeConfigSchema/routeConfigSchema.js

@@ -9,9 +9,9 @@ Object.defineProperty(exports, "routeConfigSchema", {
     }
 });
 const _zod = require("zod");
-const _helpers = require("../../../../src/utils/helpers");
-const _helpers1 = require("../../../helpers");
+const _helpers = require("../../../helpers");
 const _interceptorsSchema = require("../../interceptorsSchema/interceptorsSchema");
+const _isOnlyRequestedDataResolvingPropertyExists = require("../../isOnlyRequestedDataResolvingPropertyExists");
 const _queueSchema = require("../../queueSchema/queueSchema");
 const _settingsSchema = require("../../settingsSchema/settingsSchema");
 const _utils = require("../../utils");
@@ -28,7 +28,7 @@ const entitiesByEntityNameSchema = (method)=>{
         params: _utils.mappedEntitySchema.optional(),
         query: _utils.mappedEntitySchema.optional(),
         ...isMethodWithBody && {
-            body: _utils.plainEntitySchema.optional()
+            body: _utils.bodyPlainEntitySchema.optional()
         }
     }));
 };
@@ -58,7 +58,7 @@ const queueRouteConfigSchema = (method)=>_zod.z.strictObject({
         queue: _queueSchema.queueSchema
     }).merge(baseRouteConfigSchema(method));
 const routeConfigSchema = (method)=>_zod.z.union([
-        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _helpers1.isOnlyRequestedDataResolvingPropertyExists)(value, 'data')).pipe(dataRouteConfigSchema(method)),
-        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _helpers1.isOnlyRequestedDataResolvingPropertyExists)(value, 'file')).pipe(fileRouteConfigSchema(method)),
-        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _helpers1.isOnlyRequestedDataResolvingPropertyExists)(value, 'queue')).pipe(queueRouteConfigSchema(method))
+        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _isOnlyRequestedDataResolvingPropertyExists.isOnlyRequestedDataResolvingPropertyExists)(value, 'data')).pipe(dataRouteConfigSchema(method)),
+        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _isOnlyRequestedDataResolvingPropertyExists.isOnlyRequestedDataResolvingPropertyExists)(value, 'file')).pipe(fileRouteConfigSchema(method)),
+        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _isOnlyRequestedDataResolvingPropertyExists.isOnlyRequestedDataResolvingPropertyExists)(value, 'queue')).pipe(queueRouteConfigSchema(method))
     ]);

package/dist/src/utils/validate/utils/checkModeSchema/checkModeSchema.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const checkActualValueCheckModeSchema: z.ZodEnum<["exists", "notExists"]>;
+export declare const compareWithDescriptorAnyValueCheckModeSchema: z.ZodEnum<["equals", "notEquals"]>;
+export declare const compareWithDescriptorStringValueCheckModeSchema: z.ZodEnum<["includes", "notIncludes", "startsWith", "notStartsWith", "endsWith", "notEndsWith"]>;
+export declare const compareWithDescriptorValueCheckModeSchema: z.ZodEnum<["equals", "notEquals", "includes", "notIncludes", "startsWith", "notStartsWith", "endsWith", "notEndsWith"]>;
+export interface EntityDescriptorSchema {
+    (checkModeSchema: typeof checkActualValueCheckModeSchema): z.ZodObject<{
+        checkMode: typeof checkModeSchema;
+    }, 'strict'>;
+    (checkModeSchema: z.ZodLiteral<'function'> | z.ZodLiteral<'regExp'> | typeof compareWithDescriptorAnyValueCheckModeSchema | typeof compareWithDescriptorStringValueCheckModeSchema | typeof compareWithDescriptorValueCheckModeSchema, valueSchema: z.ZodTypeAny): z.ZodDiscriminatedUnion<'oneOf', [
+        z.ZodObject<{
+            checkMode: typeof checkModeSchema;
+            oneOf: z.ZodLiteral<true>;
+            value: z.ZodArray<typeof valueSchema>;
+        }, 'strict'>,
+        z.ZodObject<{
+            checkMode: typeof checkModeSchema;
+            oneOf: z.ZodOptional<z.ZodLiteral<false>>;
+            value: typeof valueSchema;
+        }, 'strict'>
+    ]>;
+}
+export declare const entityDescriptorSchema: EntityDescriptorSchema;

package/dist/{bin/validateMockServerConfig → src/utils/validate}/utils/checkModeSchema/checkModeSchema.js

@@ -20,11 +20,34 @@ _export(exports, {
     },
     compareWithDescriptorValueCheckModeSchema: function() {
         return compareWithDescriptorValueCheckModeSchema;
+    },
+    entityDescriptorSchema: function() {
+        return entityDescriptorSchema;
     }
 });
 const _zod = require("zod");
-const _constants = require("../../../../src/utils/constants");
+const _constants = require("../../../constants");
 const checkActualValueCheckModeSchema = _zod.z.enum(_constants.CHECK_ACTUAL_VALUE_CHECK_MODES);
 const compareWithDescriptorAnyValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES);
 const compareWithDescriptorStringValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES);
 const compareWithDescriptorValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES);
+const entityDescriptorSchema = (checkModeSchema, valueSchema)=>{
+    const isCheckActualValueCheckMode = !valueSchema;
+    if (isCheckActualValueCheckMode) {
+        return _zod.z.strictObject({
+            checkMode: checkModeSchema
+        });
+    }
+    return _zod.z.discriminatedUnion('oneOf', [
+        _zod.z.strictObject({
+            checkMode: checkModeSchema,
+            value: valueSchema,
+            oneOf: _zod.z.literal(false).optional()
+        }),
+        _zod.z.strictObject({
+            checkMode: checkModeSchema,
+            value: _zod.z.array(valueSchema),
+            oneOf: _zod.z.literal(true)
+        })
+    ]);
+};

package/dist/src/utils/validate/utils/entitiesSchema/entitiesSchema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const bodyPlainEntitySchema: z.ZodUnion<[z.ZodEffects<z.ZodType<unknown, z.ZodTypeDef, unknown>, unknown, unknown>, z.ZodPipeline<z.ZodEffects<z.ZodType<unknown, z.ZodTypeDef, unknown>, unknown, unknown>, z.ZodTypeAny>, z.ZodArray<z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodType<import("../../../types").NestedObjectOrArray<string | number | boolean | null>, z.ZodTypeDef, import("../../../types").NestedObjectOrArray<string | number | boolean | null>>]>, "many">]>;
+export declare const variablesPlainEntitySchema: z.ZodUnion<[z.ZodEffects<z.ZodType<unknown, z.ZodTypeDef, unknown>, unknown, unknown>, z.ZodPipeline<z.ZodEffects<z.ZodType<unknown, z.ZodTypeDef, unknown>, unknown, unknown>, z.ZodTypeAny>]>;
+export declare const mappedEntitySchema: z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodTypeAny>;

package/dist/src/utils/validate/utils/entitiesSchema/entitiesSchema.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    bodyPlainEntitySchema: function() {
+        return bodyPlainEntitySchema;
+    },
+    mappedEntitySchema: function() {
+        return mappedEntitySchema;
+    },
+    variablesPlainEntitySchema: function() {
+        return variablesPlainEntitySchema;
+    }
+});
+const _zod = require("zod");
+const _helpers = require("../../../helpers");
+const _checkModeSchema = require("../checkModeSchema/checkModeSchema");
+const _extendedDiscriminatedUnion = require("../extendedDiscriminatedUnion/extendedDiscriminatedUnion");
+const _nestedObjectOrArraySchema = require("../nestedObjectOrArraySchema/nestedObjectOrArraySchema");
+const _plainObjectSchema = require("../plainObjectSchema/plainObjectSchema");
+/* ----- Plain entity schema ----- */ const plainEntityPrimitiveValueSchema = _zod.z.union([
+    _zod.z.string(),
+    _zod.z.number(),
+    _zod.z.boolean(),
+    _zod.z.null()
+]);
+const plainEntityObjectiveValueSchema = (0, _nestedObjectOrArraySchema.nestedObjectOrArraySchema)(plainEntityPrimitiveValueSchema);
+const topLevelPlainEntityDescriptorSchema = (0, _extendedDiscriminatedUnion.extendedDiscriminatedUnion)('checkMode', [
+    (0, _checkModeSchema.entityDescriptorSchema)(_checkModeSchema.checkActualValueCheckModeSchema),
+    (0, _checkModeSchema.entityDescriptorSchema)(_zod.z.literal('function'), _zod.z.function()),
+    (0, _checkModeSchema.entityDescriptorSchema)(_checkModeSchema.compareWithDescriptorAnyValueCheckModeSchema, plainEntityObjectiveValueSchema)
+]);
+const propertyLevelPlainEntityDescriptorSchema = (0, _extendedDiscriminatedUnion.extendedDiscriminatedUnion)('checkMode', [
+    (0, _checkModeSchema.entityDescriptorSchema)(_checkModeSchema.checkActualValueCheckModeSchema),
+    (0, _checkModeSchema.entityDescriptorSchema)(_zod.z.literal('function'), _zod.z.function()),
+    (0, _checkModeSchema.entityDescriptorSchema)(_zod.z.literal('regExp'), _zod.z.instanceof(RegExp)),
+    (0, _checkModeSchema.entityDescriptorSchema)(_checkModeSchema.compareWithDescriptorAnyValueCheckModeSchema, _zod.z.union([
+        plainEntityPrimitiveValueSchema,
+        plainEntityObjectiveValueSchema
+    ])),
+    (0, _checkModeSchema.entityDescriptorSchema)(_checkModeSchema.compareWithDescriptorStringValueCheckModeSchema, plainEntityPrimitiveValueSchema)
+]);
+const nonCheckModeSchema = (schema)=>_zod.z.custom((value)=>typeof value === 'object').superRefine((value, context)=>{
+        if ((0, _helpers.isPlainObject)(value) && 'checkMode' in value) {
+            context.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                path: [
+                    'checkMode'
+                ],
+                fatal: true
+            });
+            return _zod.z.NEVER;
+        }
+    }).pipe(schema);
+const topLevelPlainEntityRecordSchema = nonCheckModeSchema(_zod.z.record(_zod.z.union([
+    propertyLevelPlainEntityDescriptorSchema,
+    nonCheckModeSchema(plainEntityObjectiveValueSchema),
+    plainEntityPrimitiveValueSchema
+])));
+const topLevelPlainEntityArraySchema = _zod.z.array(_zod.z.union([
+    plainEntityPrimitiveValueSchema,
+    plainEntityObjectiveValueSchema
+]));
+const bodyPlainEntitySchema = _zod.z.union([
+    topLevelPlainEntityDescriptorSchema,
+    topLevelPlainEntityRecordSchema,
+    topLevelPlainEntityArraySchema
+]);
+const variablesPlainEntitySchema = _zod.z.union([
+    topLevelPlainEntityDescriptorSchema,
+    topLevelPlainEntityRecordSchema
+]);
+/* ----- Mapped entity schema ----- */ const mappedEntityValueSchema = _zod.z.union([
+    _zod.z.string(),
+    _zod.z.number(),
+    _zod.z.boolean()
+]);
+const mappedEntityDescriptorSchema = (0, _extendedDiscriminatedUnion.extendedDiscriminatedUnion)('checkMode', [
+    (0, _checkModeSchema.entityDescriptorSchema)(_checkModeSchema.checkActualValueCheckModeSchema),
+    (0, _checkModeSchema.entityDescriptorSchema)(_zod.z.literal('function'), _zod.z.function()),
+    (0, _checkModeSchema.entityDescriptorSchema)(_zod.z.literal('regExp'), _zod.z.instanceof(RegExp)),
+    (0, _checkModeSchema.entityDescriptorSchema)(_checkModeSchema.compareWithDescriptorValueCheckModeSchema, mappedEntityValueSchema)
+]);
+const mappedEntitySchema = (0, _plainObjectSchema.plainObjectSchema)(_zod.z.record(_zod.z.union([
+    mappedEntityValueSchema,
+    mappedEntityDescriptorSchema
+])));

package/dist/src/utils/validate/utils/extendedDiscriminatedUnion/extendedDiscriminatedUnion.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+type ExtendedDiscriminatedUnionVariant<Discriminator extends string, Option extends z.ZodObject<{
+    [Key in Discriminator]: z.ZodTypeAny;
+}> = z.ZodObject<{
+    [Key in Discriminator]: z.ZodTypeAny;
+}>> = Option | z.ZodDiscriminatedUnion<string, [Option, ...Option[]]>;
+export declare const extendedDiscriminatedUnion: <Discriminator extends string>(discriminator: Discriminator, variants: [ExtendedDiscriminatedUnionVariant<Discriminator>, ...ExtendedDiscriminatedUnionVariant<Discriminator>[]]) => z.ZodEffects<z.ZodType<unknown, z.ZodTypeDef, unknown>, unknown, unknown>;
+export {};

package/dist/src/utils/validate/utils/extendedDiscriminatedUnion/extendedDiscriminatedUnion.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "extendedDiscriminatedUnion", {
+    enumerable: true,
+    get: function() {
+        return extendedDiscriminatedUnion;
+    }
+});
+const _zod = require("zod");
+const _helpers = require("../../../helpers");
+const _getMostSpecificPathFromError = require("../../getMostSpecificPathFromError");
+const extendedDiscriminatedUnion = (discriminator, variants)=>_zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && discriminator in value).superRefine((value, context)=>{
+        const variantWithMatchedDiscriminator = variants.find((variant)=>{
+            const isVariantOption = variant instanceof _zod.z.ZodDiscriminatedUnion;
+            if (isVariantOption) {
+                return variant.options.some((option)=>option.strip().pick({
+                        [discriminator]: true
+                    }).safeParse(value).success);
+            }
+            return variant.strip().pick({
+                [discriminator]: true
+            }).safeParse(value).success;
+        });
+        if (!variantWithMatchedDiscriminator) {
+            context.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                path: [
+                    discriminator
+                ],
+                fatal: true
+            });
+            return _zod.z.NEVER;
+        }
+        const valueParseResult = variantWithMatchedDiscriminator.safeParse(value);
+        if (!valueParseResult.success) {
+            const issuePath = (0, _getMostSpecificPathFromError.getMostSpecificPathFromError)(valueParseResult.error);
+            context.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                path: issuePath,
+                fatal: true
+            });
+            return _zod.z.NEVER;
+        }
+    });

package/dist/{bin/validateMockServerConfig → src/utils/validate}/utils/index.d.ts

@@ -1,6 +1,6 @@
 export * from './checkModeSchema/checkModeSchema';
 export * from './entitiesSchema/entitiesSchema';
-export * from './jsonSchema/jsonSchema';
+export * from './extendedDiscriminatedUnion/extendedDiscriminatedUnion';
+export * from './nestedObjectOrArraySchema/nestedObjectOrArraySchema';
 export * from './plainObjectSchema/plainObjectSchema';
-export * from './requiredPropertiesSchema/requiredPropertiesSchema';
 export * from './sharedSchema/sharedSchema';

package/dist/{bin/validateMockServerConfig → src/utils/validate}/utils/index.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 _export_star(require("./checkModeSchema/checkModeSchema"), exports);
 _export_star(require("./entitiesSchema/entitiesSchema"), exports);
-_export_star(require("./jsonSchema/jsonSchema"), exports);
+_export_star(require("./extendedDiscriminatedUnion/extendedDiscriminatedUnion"), exports);
+_export_star(require("./nestedObjectOrArraySchema/nestedObjectOrArraySchema"), exports);
 _export_star(require("./plainObjectSchema/plainObjectSchema"), exports);
-_export_star(require("./requiredPropertiesSchema/requiredPropertiesSchema"), exports);
 _export_star(require("./sharedSchema/sharedSchema"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/dist/{bin/validateMockServerConfig → src/utils/validate}/utils/jsonSchema/jsonSchema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const jsonLiteralSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
 type JsonLiteral = z.infer<typeof jsonLiteralSchema>;
-type Json = JsonLiteral | {
+type Json = Json[] | JsonLiteral | {
     [key: string]: Json;
-} | Json[];
+};
 export declare const jsonSchema: z.ZodType<Json>;
 export {};

package/dist/{bin/validateMockServerConfig → src/utils/validate}/utils/jsonSchema/jsonSchema.js

@@ -17,7 +17,7 @@ _export(exports, {
     }
 });
 const _zod = require("zod");
-const _helpers = require("../../../../src/utils/helpers");
+const _helpers = require("../../../helpers");
 const jsonLiteralSchema = _zod.z.union([
     _zod.z.string(),
     _zod.z.number(),

package/dist/src/utils/validate/utils/nestedObjectOrArraySchema/nestedObjectOrArraySchema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { NestedObjectOrArray } from '../../../types';
+export declare const nestedObjectOrArraySchema: <Value>(valueSchema: z.ZodType<Value>) => z.ZodType<NestedObjectOrArray<Value>>;

package/dist/src/utils/validate/utils/nestedObjectOrArraySchema/nestedObjectOrArraySchema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nestedObjectOrArraySchema", {
+    enumerable: true,
+    get: function() {
+        return nestedObjectOrArraySchema;
+    }
+});
+const _zod = require("zod");
+const _helpers = require("../../../helpers");
+const nestedObjectOrArraySchema = (valueSchema)=>{
+    const nestedValueSchema = _zod.z.union([
+        valueSchema,
+        _zod.z.lazy(()=>nestedObjectOrArraySchema(valueSchema))
+    ]);
+    return _zod.z.union([
+        _zod.z.array(nestedValueSchema),
+        _zod.z.record(nestedValueSchema).and(_zod.z.custom((value)=>(0, _helpers.isPlainObject)(value)))
+    ]);
+};

package/dist/{bin/validateMockServerConfig → src/utils/validate}/utils/requiredPropertiesSchema/requiredPropertiesSchema.d.ts

@@ -1,3 +1,3 @@
 import { z } from 'zod';
-import type { PlainObject } from '../../../../src/utils/types';
+import type { PlainObject } from '../../../types';
 export declare const requiredPropertiesSchema: <T extends PlainObject>(schema: z.ZodType<T>, requiredProperties: (keyof T)[]) => z.ZodPipeline<z.ZodType<unknown, z.ZodTypeDef, unknown>, z.ZodType<T, z.ZodTypeDef, T>>;

package/dist/{bin/validateMockServerConfig → src/utils/validate}/utils/requiredPropertiesSchema/requiredPropertiesSchema.js

@@ -9,5 +9,5 @@ Object.defineProperty(exports, "requiredPropertiesSchema", {
     }
 });
 const _zod = require("zod");
-const _helpers = require("../../../../src/utils/helpers");
+const _helpers = require("../../../helpers");
 const requiredPropertiesSchema = (schema, requiredProperties)=>_zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && requiredProperties.every((property)=>Object.prototype.hasOwnProperty.call(value, property))).pipe(schema);

package/dist/src/utils/validate/validateApiMockServerConfig.d.ts

@@ -0,0 +1,2 @@
+import type { PlainObject } from '../types';
+export declare const validateApiMockServerConfig: (mockServerConfig: PlainObject, api: "graphql" | "rest") => void;

package/dist/{bin/validateMockServerConfig → src/utils/validate}/validateApiMockServerConfig.js

@@ -9,10 +9,11 @@ Object.defineProperty(exports, "validateApiMockServerConfig", {
     }
 });
 const _zod = require("zod");
-const _helpers = require("../helpers");
 const _baseUrlSchema = require("./baseUrlSchema/baseUrlSchema");
 const _corsSchema = require("./corsSchema/corsSchema");
 const _databaseConfigSchema = require("./databaseConfigSchema/databaseConfigSchema");
+const _getMostSpecificPathFromError = require("./getMostSpecificPathFromError");
+const _getValidationMessageFromPath = require("./getValidationMessageFromPath");
 const _graphqlConfigSchema = require("./graphqlConfigSchema/graphqlConfigSchema");
 const _interceptorsSchema = require("./interceptorsSchema/interceptorsSchema");
 const _portSchema = require("./portSchema/portSchema");
@@ -40,8 +41,8 @@ const validateApiMockServerConfig = (mockServerConfig, api)=>{
     });
     const validationResult = mockServerConfigSchema.safeParse(mockServerConfig);
     if (!validationResult.success) {
-        const path = (0, _helpers.getMostSpecificPathFromError)(validationResult.error);
-        const validationMessage = (0, _helpers.getValidationMessageFromPath)(path);
+        const path = (0, _getMostSpecificPathFromError.getMostSpecificPathFromError)(validationResult.error);
+        const validationMessage = (0, _getValidationMessageFromPath.getValidationMessageFromPath)(path);
         throw new Error(`Validation Error: configuration${validationMessage} does not match the API schema. Click here to see correct type: https://github.com/siberiacancode/mock-config-server`);
     }
 };

package/dist/src/utils/validate/validateFlatMockServerConfig.d.ts

@@ -0,0 +1,2 @@
+import type { PlainObject } from '../types';
+export declare const validateFlatMockServerConfig: (flatMockServerConfig: PlainObject) => void;

package/dist/src/utils/validate/validateFlatMockServerConfig.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateFlatMockServerConfig", {
+    enumerable: true,
+    get: function() {
+        return validateFlatMockServerConfig;
+    }
+});
+const _zod = require("zod");
+const _baseUrlSchema = require("./baseUrlSchema/baseUrlSchema");
+const _corsSchema = require("./corsSchema/corsSchema");
+const _databaseConfigSchema = require("./databaseConfigSchema/databaseConfigSchema");
+const _getMostSpecificPathFromError = require("./getMostSpecificPathFromError");
+const _getValidationMessageFromPath = require("./getValidationMessageFromPath");
+const _graphqlConfigSchema = require("./graphqlConfigSchema/graphqlConfigSchema");
+const _interceptorsSchema = require("./interceptorsSchema/interceptorsSchema");
+const _portSchema = require("./portSchema/portSchema");
+const _restConfigSchema = require("./restConfigSchema/restConfigSchema");
+const _staticPathSchema = require("./staticPathSchema/staticPathSchema");
+const _utils = require("./utils");
+const validateFlatMockServerConfig = (flatMockServerConfig)=>{
+    if (!flatMockServerConfig.length) {
+        throw new Error('Flat config should contain at least one element; see our doc (https://github.com/siberiacancode/mock-config-server) for more information');
+    }
+    const flatMockServerSettingsSchema = _zod.z.strictObject({
+        baseUrl: _baseUrlSchema.baseUrlSchema.optional(),
+        port: _portSchema.portSchema.optional(),
+        staticPath: _staticPathSchema.staticPathSchema.optional(),
+        interceptors: (0, _utils.plainObjectSchema)(_interceptorsSchema.interceptorsSchema).optional(),
+        cors: _corsSchema.corsSchema.optional(),
+        database: _databaseConfigSchema.databaseConfigSchema.optional()
+    });
+    const flatMockServerComponentSchema = _zod.z.strictObject({
+        name: _zod.z.string().optional(),
+        baseUrl: _baseUrlSchema.baseUrlSchema.optional(),
+        interceptors: (0, _utils.plainObjectSchema)(_interceptorsSchema.interceptorsSchema).optional(),
+        configs: _zod.z.array(_zod.z.union([
+            _restConfigSchema.restRequestConfigSchema,
+            _graphqlConfigSchema.graphqlRequestConfigSchema
+        ]))
+    });
+    const flatMockServerConfigSchema = _zod.z.tuple([
+        (0, _utils.plainObjectSchema)(flatMockServerSettingsSchema).or(flatMockServerComponentSchema)
+    ]).rest(flatMockServerComponentSchema);
+    const validationFlatMockServerConfigSchemaResult = flatMockServerConfigSchema.safeParse(flatMockServerConfig);
+    if (!validationFlatMockServerConfigSchemaResult.success) {
+        const path = (0, _getMostSpecificPathFromError.getMostSpecificPathFromError)(validationFlatMockServerConfigSchemaResult.error);
+        const validationMessage = (0, _getValidationMessageFromPath.getValidationMessageFromPath)(path);
+        throw new Error(`Validation Error: configuration${validationMessage} does not match the API schema. Click here to see correct type: https://github.com/siberiacancode/mock-config-server`);
+    }
+};

package/dist/{bin/validateMockServerConfig → src/utils/validate}/validateMockServerConfig.d.ts

@@ -1,2 +1,2 @@
-import type { PlainObject } from '../../src';
+import type { PlainObject } from '../types';
 export declare const validateMockServerConfig: (mockServerConfig: PlainObject) => void;

package/dist/{bin/validateMockServerConfig → src/utils/validate}/validateMockServerConfig.js

@@ -9,10 +9,11 @@ Object.defineProperty(exports, "validateMockServerConfig", {
     }
 });
 const _zod = require("zod");
-const _helpers = require("../helpers");
 const _baseUrlSchema = require("./baseUrlSchema/baseUrlSchema");
 const _corsSchema = require("./corsSchema/corsSchema");
 const _databaseConfigSchema = require("./databaseConfigSchema/databaseConfigSchema");
+const _getMostSpecificPathFromError = require("./getMostSpecificPathFromError");
+const _getValidationMessageFromPath = require("./getValidationMessageFromPath");
 const _graphqlConfigSchema = require("./graphqlConfigSchema/graphqlConfigSchema");
 const _interceptorsSchema = require("./interceptorsSchema/interceptorsSchema");
 const _portSchema = require("./portSchema/portSchema");
@@ -35,8 +36,8 @@ const validateMockServerConfig = (mockServerConfig)=>{
     });
     const validationResult = mockServerConfigSchema.safeParse(mockServerConfig);
     if (!validationResult.success) {
-        const path = (0, _helpers.getMostSpecificPathFromError)(validationResult.error);
-        const validationMessage = (0, _helpers.getValidationMessageFromPath)(path);
+        const path = (0, _getMostSpecificPathFromError.getMostSpecificPathFromError)(validationResult.error);
+        const validationMessage = (0, _getValidationMessageFromPath.getValidationMessageFromPath)(path);
         throw new Error(`Validation Error: configuration${validationMessage} does not match the API schema. Click here to see correct type: https://github.com/siberiacancode/mock-config-server`);
     }
 };