@rosen-bridge/config 0.2.1 → 0.4.0

package/tests/configTestData.ts

@@ -1,5 +1,4 @@
 import { cloneDeep } from 'lodash-es';
-
 export const apiSchemaDefaultValuePairSample = {
   schema: {
     apiType: {
@@ -961,6 +960,7 @@ export const apiSchemaConfigPairWithStringBigInt = {
       children: {
         port: {
           type: 'bigint',
+          default: '5372',
         },
       },
     },
@@ -1091,7 +1091,7 @@ export const schemaTypeScriptTypesPair = {
   types: `export interface Infrastructure {
   apis: Apis;
   server: Server;
-  explorer: Explorer1;
+  explorer: Explorer;
   logs: Logs[];
   apiType?: 'node' | 'explorer' | 'superApi';
 }
@@ -1104,7 +1104,7 @@ export interface Logs {
   level?: string;
 }
 
-export interface Explorer1 {
+export interface Explorer {
   domain?: string;
   path?: string;
 }
@@ -1115,10 +1115,10 @@ export interface Server {
 }
 
 export interface Apis {
-  explorer: Explorer;
+  explorer: ApisExplorer;
 }
 
-export interface Explorer {
+export interface ApisExplorer {
   url?: string;
   port?: number;
 }
@@ -1214,3 +1214,522 @@ export const schemaConfigCharPair = {
     },
   },
 };
+
+// logs array schema with item-level defaults and array default elements
+export const logsArraySchemaDefaultsPair = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          type: {
+            type: 'string',
+            validations: [
+              {
+                required: true,
+                error: 'log type must be specified',
+              },
+              { choices: ['file', 'console', 'loki'] },
+            ],
+          },
+          maxSize: {
+            type: 'string',
+            validations: [
+              {
+                required: true,
+                error: 'maxSize for file log type must be specified',
+                when: { path: 'logs.type', value: 'file' },
+              },
+            ],
+          },
+          maxFiles: {
+            type: 'string',
+            validations: [
+              {
+                required: true,
+                error: 'maxFiles for file log type must be specified',
+                when: { path: 'logs.type', value: 'file' },
+              },
+            ],
+          },
+          path: {
+            type: 'string',
+            default: '/var/log/app.log',
+            validations: [
+              {
+                required: true,
+                error: 'path for file log type must be specified',
+                when: { path: 'logs.type', value: 'file' },
+              },
+            ],
+          },
+          level: {
+            type: 'string',
+            default: 'info',
+            validations: [
+              {
+                required: true,
+                error: 'log level must be specified',
+                when: { path: 'logs.type', value: 'file' },
+              },
+            ],
+          },
+        },
+      },
+      default: [{ type: 'file', level: 'debug' }, { type: 'console' }],
+    },
+  },
+  defaultVal: {
+    logs: [
+      { type: 'file', level: 'debug', path: '/var/log/app.log' },
+      { type: 'console', level: 'info', path: '/var/log/app.log' },
+    ],
+  },
+};
+
+// empty array defaults for primitive types
+export const emptyArrayDefaultsPair = {
+  schema: {
+    emptyStringArray: {
+      type: 'array' as const,
+      default: [],
+      items: { type: 'string' as const },
+    },
+    emptyNumberArray: {
+      type: 'array' as const,
+      default: [],
+      items: { type: 'number' as const },
+    },
+  },
+  defaultVal: {
+    emptyStringArray: [],
+    emptyNumberArray: [],
+  },
+};
+
+// schema including an array without default to be excluded from defaults result
+export const arrayWithoutDefaultPair = {
+  schema: {
+    withDefault: {
+      type: 'string' as const,
+      default: 'test',
+    },
+    arrayWithoutDefault: {
+      type: 'array' as const,
+      items: { type: 'string' as const },
+    },
+  },
+  defaultVal: {
+    withDefault: 'test',
+  },
+};
+
+// logs array with invalid defaults (choices violation, missing required) plus expected generated defaults
+export const invalidLogsArrayDefaultsPair = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          type: {
+            type: 'string',
+            validations: [
+              { required: true, error: 'log type must be specified' },
+              { choices: ['file', 'console', 'loki'] },
+            ],
+          },
+          path: { type: 'string', default: '/var/log/app.log' },
+          level: { type: 'string', default: 'info' },
+        },
+      },
+      default: [{ type: 'unknown' as any }, { level: 'debug' }],
+    },
+  },
+  defaultVal: {
+    logs: [
+      { type: 'unknown', path: '/var/log/app.log', level: 'info' },
+      { level: 'debug', path: '/var/log/app.log' },
+    ],
+  },
+};
+
+// logs array with unknown key inside defaults, plus expected generated defaults
+export const unknownKeyLogsArrayDefaultsPair = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          path: { type: 'string', default: '/var/log/app.log' },
+          level: { type: 'string', default: 'info' },
+        },
+      },
+      default: [{ pathsskddkfjd: '/tmp/weird' } as any],
+    },
+  },
+  defaultVal: {
+    logs: [
+      { path: '/var/log/app.log', level: 'info', pathsskddkfjd: '/tmp/weird' },
+    ],
+  },
+};
+
+// Schemas for duplicate key/type generation tests
+export const duplicateChildKeysSchema = {
+  schema: {
+    user: {
+      type: 'object',
+      children: {
+        database: {
+          type: 'object',
+          children: {
+            host: { type: 'string' },
+            port: { type: 'number' },
+          },
+        },
+      },
+    },
+    apis: {
+      type: 'object',
+      children: {
+        explorer: {
+          type: 'object',
+          children: {
+            url: { type: 'string' },
+            port: { type: 'number' },
+          },
+        },
+      },
+    },
+  },
+};
+
+export const identicalStructurePathsSchema = {
+  schema: {
+    primary: {
+      type: 'object',
+      children: {
+        connection: {
+          type: 'object',
+          children: {
+            host: { type: 'string' },
+            port: { type: 'number' },
+            ssl: { type: 'boolean' },
+          },
+        },
+      },
+    },
+    backup: {
+      type: 'object',
+      children: {
+        connection: {
+          type: 'object',
+          children: {
+            host: { type: 'string' },
+            port: { type: 'number' },
+            ssl: { type: 'boolean' },
+          },
+        },
+      },
+    },
+  },
+};
+
+export const arrayItemsAtRootSchema = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          message: { type: 'string' },
+          level: { type: 'string' },
+        },
+      },
+    },
+  },
+};
+
+// Nested defaults: array of objects where an item key is itself a nested array
+export const nestedArrayInArrayDefaultsPair = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          name: { type: 'string', default: 'file' },
+          tags: {
+            type: 'array',
+            items: { type: 'string' },
+            default: ['t1', 't2'],
+          },
+          labels: {
+            type: 'array',
+            items: { type: 'string' },
+            default: ['L1'],
+          },
+        },
+      },
+      default: [{}, { tags: ['custom'], labels: [] }],
+    },
+  },
+  defaultVal: {
+    logs: [
+      { name: 'file', tags: ['t1', 't2'], labels: ['L1'] },
+      { name: 'file', tags: ['custom'], labels: [] },
+    ],
+  },
+};
+
+// Schema for invalid defaults used with generateDefault({ validate: true })
+export const invalidDefaultsValidateOptionSchema = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          type: {
+            type: 'string',
+            validations: [
+              { required: true },
+              { choices: ['file', 'console', 'loki'] },
+            ],
+          },
+          level: { type: 'string', default: 'info' },
+        },
+      },
+      default: [{ type: 'unknown' as any }, { level: 'debug' }],
+    },
+  },
+};
+
+// Schema for required field without default
+export const requiredWithoutDefaultSchema = {
+  schema: {
+    service: {
+      type: 'object',
+      children: {
+        apiKey: {
+          type: 'string',
+          validations: [{ required: true }],
+        },
+      },
+    },
+  },
+};
+
+// Default-shape validation fixtures
+export const arrayPrimitiveDefaultsValid = {
+  schema: {
+    ports: {
+      type: 'array',
+      items: { type: 'number' },
+      default: [80, 443],
+    },
+  },
+};
+
+export const arrayPrimitiveDefaultsInvalid = {
+  schema: {
+    ports: {
+      type: 'array',
+      items: { type: 'number' },
+      // invalid: contains a string
+      default: [80, '443' as any],
+    },
+  },
+};
+
+export const arrayObjectDefaultsInvalidChildType = {
+  schema: {
+    services: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          enabled: { type: 'boolean' },
+          path: { type: 'string' },
+        },
+      },
+      // invalid: enabled should be boolean
+      default: [{ enabled: 'true' as any, path: '/var' }],
+    },
+  },
+};
+
+export const nestedArrayDefaultsInvalid = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          name: { type: 'string' },
+          tags: { type: 'array', items: { type: 'string' } },
+        },
+      },
+      // invalid: tags contains a number
+      default: [{ name: 'file', tags: ['ok', 1 as any] }],
+    },
+  },
+};
+
+export const nestedArrayDefaultsValid = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          name: { type: 'string' },
+          tags: { type: 'array', items: { type: 'string' } },
+        },
+      },
+      default: [{ name: 'file', tags: ['ok', 'x'] }],
+    },
+  },
+};
+
+// Nested array of objects inside array of objects (valid)
+export const nestedArrayOfObjectsDefaultsValid = {
+  schema: {
+    services: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          name: { type: 'string' },
+          handlers: {
+            type: 'array',
+            items: {
+              type: 'object',
+              children: {
+                type: { type: 'string' },
+                retries: { type: 'number' },
+              },
+            },
+            default: [{ type: 'file', retries: 3 }],
+          },
+        },
+      },
+      default: [
+        { name: 'api' },
+        { name: 'worker', handlers: [{ type: 'console', retries: 1 }] },
+      ],
+    },
+  },
+  defaultVal: {
+    services: [
+      { name: 'api', handlers: [{ type: 'file', retries: 3 }] },
+      { name: 'worker', handlers: [{ type: 'console', retries: 1 }] },
+    ],
+  },
+};
+
+// Nested array of objects inside array of objects (invalid inner element shape)
+export const nestedArrayOfObjectsDefaultsInvalid = {
+  schema: {
+    services: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          name: { type: 'string' },
+          handlers: {
+            type: 'array',
+            items: {
+              type: 'object',
+              children: {
+                type: { type: 'string' },
+                retries: { type: 'number' },
+              },
+            },
+            // invalid: retries should be number, unknown key also invalid
+            default: [
+              { type: 'file', retries: 'three' as any, extra: true as any },
+            ],
+          },
+        },
+      },
+      default: [{ name: 'api' }],
+    },
+  },
+};
+
+// Wrong choice default at primitive level
+export const wrongChoiceDefaultSchema = {
+  schema: {
+    mode: {
+      type: 'string',
+      default: 'good',
+      validations: [{ choices: ['hello', 'bye'] }],
+    },
+  },
+};
+
+// Wrong choice default nested in array of objects
+export const nestedWrongChoiceDefaultSchema = {
+  schema: {
+    logs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        children: {
+          type: {
+            type: 'string',
+            default: 'unknown',
+            validations: [{ choices: ['file', 'console', 'loki'] }],
+          },
+          level: { type: 'string', default: 'info' },
+        },
+      },
+      default: [{}],
+    },
+  },
+};
+
+export const arraySchemaDefaultValuePairSample = {
+  schema: {
+    stringArray: {
+      type: 'array',
+      default: ['item1', 'item2', 'item3'],
+      description: 'array of strings',
+      items: {
+        type: 'string',
+      },
+    },
+    numberArray: {
+      type: 'array',
+      default: [1, 2, 3, 42],
+      description: 'array of numbers',
+      items: {
+        type: 'number',
+      },
+    },
+    emptyArray: {
+      type: 'array',
+      default: [],
+      description: 'empty array',
+      items: {
+        type: 'string',
+      },
+    },
+    noDefaultArray: {
+      type: 'array',
+      description: 'array without default',
+      items: {
+        type: 'boolean',
+      },
+    },
+  },
+  defaultVal: {
+    stringArray: ['item1', 'item2', 'item3'],
+    numberArray: [1, 2, 3, 42],
+    emptyArray: [],
+  },
+};

package/tsconfig.build.json

@@ -1,7 +1,8 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "rootDir": "./lib"
+    "rootDir": "./lib",
+    "outDir": "./dist"
   },
   "exclude": ["tests", "vitest.config.ts"]
 }