@deepexi/datasense-connector 3.0.1 → 3.1.0

package/validate.js

@@ -1,597 +0,0 @@
-import { isSingleObjectPush, SINGLE_OBJECT_PUSH_MESSAGE } from './types.js';
-export const SDK_NAME_PATTERN = /^[a-z][a-z0-9_]{0,27}$/;
-export const RESERVED_PUSH_NAMES = Object.freeze(['dev']);
-export const DEFAULT_PUSH_NAME = 'default';
-const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
-const SCALAR_KINDS = new Set(['string', 'integer', 'decimal', 'boolean', 'date', 'instant', 'json']);
-const RETENTION_KINDS = new Set(['instant', 'date']);
-const SYNC_MODES = new Set(['full', 'incremental']);
-const SNAPSHOTS = new Set(['complete', 'partial']);
-const PURGE_KEYS = ['tenant', 'user'];
-const FIELD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const HOST_PLACEHOLDER = /\{config\.([^{}]*)\}/g;
-const HOST_LABEL = '[a-z0-9](?:[a-z0-9-]*[a-z0-9])?';
-const HOST_PATTERN = new RegExp(`^(?:\\*\\.)?${HOST_LABEL}(?:\\.${HOST_LABEL})*$`, 'i');
-const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-const INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
-const DECIMAL_TEXT_PATTERN = /^-?\d+(?:\.\d+)?$/;
-export const PRESENTATION_LIMITS = Object.freeze({
-    title: 40,
-    description: 120,
-    readmeBytes: 65536,
-    iconBytes: 262144,
-    iconMinPx: 128,
-    fieldTitle: 40,
-    fieldDescription: 200,
-    placeholder: 100,
-    tableTitle: 40,
-    tableDescription: 200,
-});
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isPositiveInteger(value) {
-    return typeof value === 'number' && Number.isInteger(value) && value > 0;
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === 'string');
-}
-function validateText(path, owner, key, max, issues) {
-    const value = owner[key];
-    if (value === undefined)
-        return;
-    if (typeof value !== 'string') {
-        issues.push({ path: `${path}.${key}`, message: `${key} must be a string` });
-    }
-    else if ([...value].length > max) {
-        issues.push({ path: `${path}.${key}`, message: `${key} must be at most ${max} characters` });
-    }
-}
-function validateFieldMeta(path, type, issues) {
-    validateText(path, type, 'title', PRESENTATION_LIMITS.fieldTitle, issues);
-    validateText(path, type, 'description', PRESENTATION_LIMITS.fieldDescription, issues);
-    if (type.placeholder !== undefined && (type.kind === 'object' || type.kind === 'array')) {
-        issues.push({ path: `${path}.placeholder`, message: 'placeholder is only allowed on scalar and secret fields' });
-        return;
-    }
-    validateText(path, type, 'placeholder', PRESENTATION_LIMITS.placeholder, issues);
-}
-function columnTypeProblem(type) {
-    if (!isRecord(type) || typeof type.kind !== 'string' || !SCALAR_KINDS.has(type.kind)) {
-        return 'column type must be a scalar type (string, integer, decimal, boolean, date, instant or json)';
-    }
-    if (type.kind === 'decimal')
-        return decimalProblem(type);
-    return null;
-}
-function decimalProblem(type) {
-    const { precision, scale } = type;
-    if (!isPositiveInteger(precision) || typeof scale !== 'number' || !Number.isInteger(scale) || scale < 0 || scale > precision) {
-        return 'decimal needs an integer precision > 0 and an integer scale between 0 and precision';
-    }
-    return null;
-}
-function validateTable(path, table, issues) {
-    if (!isRecord(table)) {
-        issues.push({ path, message: 'table declaration must be an object' });
-        return;
-    }
-    const columns = isRecord(table.columns) ? table.columns : null;
-    if (!columns) {
-        issues.push({ path: `${path}.columns`, message: 'columns must be an object' });
-        return;
-    }
-    const columnKind = (name) => {
-        const type = columns[name];
-        return isRecord(type) && typeof type.kind === 'string' ? type.kind : undefined;
-    };
-    const isDeclared = (name) => typeof name === 'string' && Object.hasOwn(columns, name);
-    for (const [name, type] of Object.entries(columns)) {
-        const problem = columnTypeProblem(type);
-        if (problem)
-            issues.push({ path: `${path}.columns.${name}`, message: problem });
-        else
-            validateFieldMeta(`${path}.columns.${name}`, type, issues);
-    }
-    validateText(path, table, 'title', PRESENTATION_LIMITS.tableTitle, issues);
-    validateText(path, table, 'description', PRESENTATION_LIMITS.tableDescription, issues);
-    const primaryKey = table.primaryKey;
-    if (!isStringArray(primaryKey) || primaryKey.length === 0) {
-        issues.push({ path: `${path}.primaryKey`, message: 'primaryKey must be a non-empty list of column names' });
-    }
-    else {
-        const missing = primaryKey.filter((name) => !isDeclared(name));
-        if (missing.length > 0) {
-            issues.push({ path: `${path}.primaryKey`, message: `primaryKey references undeclared columns: ${missing.join(', ')}` });
-        }
-    }
-    if (table.retention !== undefined) {
-        const retention = table.retention;
-        if (!isRecord(retention)) {
-            issues.push({ path: `${path}.retention`, message: 'retention must be an object' });
-        }
-        else {
-            const column = retention.column;
-            if (!isDeclared(column)) {
-                issues.push({ path: `${path}.retention.column`, message: 'retention column must be a declared column' });
-            }
-            else if (!RETENTION_KINDS.has(columnKind(column) ?? '')) {
-                issues.push({ path: `${path}.retention.column`, message: 'retention column must be of type instant or date' });
-            }
-            else if (!isStringArray(primaryKey) || !primaryKey.includes(column)) {
-                issues.push({ path: `${path}.retention.column`, message: 'retention column must be part of primaryKey' });
-            }
-            if (!isPositiveInteger(retention.days)) {
-                issues.push({ path: `${path}.retention.days`, message: 'retention days must be a positive integer' });
-            }
-        }
-    }
-    if (table.purgeColumns !== undefined) {
-        const purgeColumns = table.purgeColumns;
-        if (!isRecord(purgeColumns)) {
-            issues.push({ path: `${path}.purgeColumns`, message: 'purgeColumns must be an object' });
-        }
-        else {
-            for (const key of PURGE_KEYS) {
-                const column = purgeColumns[key];
-                if (column !== undefined && !isDeclared(column)) {
-                    issues.push({ path: `${path}.purgeColumns.${key}`, message: 'purge column must be a declared column' });
-                }
-            }
-        }
-    }
-    if (table.indexes !== undefined) {
-        const indexes = table.indexes;
-        if (!Array.isArray(indexes)) {
-            issues.push({ path: `${path}.indexes`, message: 'indexes must be a list of column lists' });
-        }
-        else {
-            indexes.forEach((index, i) => {
-                if (!isStringArray(index) || index.length === 0 || !index.every(isDeclared)) {
-                    issues.push({ path: `${path}.indexes[${i}]`, message: 'index must be a non-empty list of declared columns' });
-                }
-            });
-        }
-    }
-}
-function validateTables(path, tables, owners, owner, issues) {
-    if (!isRecord(tables)) {
-        issues.push({ path, message: 'tables must be an object' });
-        return;
-    }
-    for (const [name, table] of Object.entries(tables)) {
-        const tablePath = `${path}.${name}`;
-        if (!SDK_NAME_PATTERN.test(name)) {
-            issues.push({ path: tablePath, message: `table name must match ${SDK_NAME_PATTERN.source}` });
-        }
-        const previous = owners.get(name);
-        if (previous !== undefined) {
-            issues.push({ path: tablePath, message: `table ${name} is already declared by ${previous}` });
-        }
-        else {
-            owners.set(name, owner);
-        }
-        validateTable(tablePath, table, issues);
-    }
-}
-function validateSdkType(path, type, rules, issues) {
-    if (!isRecord(type) || typeof type.kind !== 'string') {
-        issues.push({ path, message: 'type must be declared with t.*()' });
-        return;
-    }
-    const nested = { secretAllowed: false, secretMessage: rules.secretMessage };
-    if (type.kind === 'secret' || type.kind === 'object' || type.kind === 'array' || SCALAR_KINDS.has(type.kind)) {
-        validateFieldMeta(path, type, issues);
-    }
-    switch (type.kind) {
-        case 'secret':
-            if (!rules.secretAllowed)
-                issues.push({ path, message: rules.secretMessage });
-            else if (type.exposeToScript !== undefined && typeof type.exposeToScript !== 'boolean') {
-                issues.push({ path: `${path}.exposeToScript`, message: 'exposeToScript must be a boolean' });
-            }
-            return;
-        case 'object':
-            validateShape(path, type, nested, issues);
-            return;
-        case 'array':
-            validateSdkType(`${path}[]`, type.item, nested, issues);
-            return;
-        case 'decimal': {
-            const problem = decimalProblem(type);
-            if (problem)
-                issues.push({ path, message: problem });
-            return;
-        }
-        default:
-            if (!SCALAR_KINDS.has(type.kind))
-                issues.push({ path, message: `unknown type kind ${type.kind}` });
-    }
-}
-function validateShape(path, type, fieldRules, issues) {
-    if (!isRecord(type.shape)) {
-        issues.push({ path, message: 'object type needs a shape' });
-        return;
-    }
-    for (const [field, fieldType] of Object.entries(type.shape)) {
-        const fieldPath = `${path}.${field}`;
-        if (!FIELD_NAME_PATTERN.test(field)) {
-            issues.push({ path: fieldPath, message: `field name must match ${FIELD_NAME_PATTERN.source}` });
-        }
-        validateSdkType(fieldPath, fieldType, fieldRules, issues);
-    }
-}
-function validateObjectDeclaration(path, type, rules, issues) {
-    if (!isRecord(type) || type.kind !== 'object') {
-        issues.push({ path, message: `${path} must be declared with t.object()` });
-        return false;
-    }
-    validateFieldMeta(path, type, issues);
-    validateShape(path, type, rules, issues);
-    return true;
-}
-function configFieldType(config, fieldPath) {
-    let current = config;
-    for (const segment of fieldPath.split('.')) {
-        if (!isRecord(current) || current.kind !== 'object' || !isRecord(current.shape) || !Object.hasOwn(current.shape, segment))
-            return undefined;
-        current = current.shape[segment];
-    }
-    return isRecord(current) ? current : undefined;
-}
-function pushNames(push) {
-    return isRecord(push) ? Object.keys(push) : [];
-}
-function validatePushHandler(path, handler, issues) {
-    if (!isRecord(handler)) {
-        issues.push({ path, message: 'push handler must be an object with map()' });
-        return;
-    }
-    if (handler.verify !== undefined && typeof handler.verify !== 'function') {
-        issues.push({ path: `${path}.verify`, message: `${path}.verify must be a function` });
-    }
-    if (typeof handler.map !== 'function') {
-        issues.push({ path: `${path}.map`, message: `${path}.map must be a function` });
-    }
-}
-function validatePush(push, issues) {
-    if (push === undefined)
-        return 0;
-    if (!isRecord(push)) {
-        issues.push({ path: 'push', message: 'push must be an object' });
-        return 0;
-    }
-    if (isSingleObjectPush(push)) {
-        issues.push({ path: 'push', message: SINGLE_OBJECT_PUSH_MESSAGE });
-        return 1;
-    }
-    const names = Object.keys(push);
-    if (names.length === 0) {
-        issues.push({ path: 'push', message: 'push must declare at least one handler, e.g. push: { default: { map } }' });
-        return 0;
-    }
-    for (const name of names) {
-        const path = `push.${name}`;
-        if (!SDK_NAME_PATTERN.test(name)) {
-            issues.push({ path, message: `push name must match ${SDK_NAME_PATTERN.source}` });
-        }
-        else if (RESERVED_PUSH_NAMES.includes(name)) {
-            issues.push({ path, message: `push name ${name} is reserved` });
-        }
-        validatePushHandler(path, push[name], issues);
-    }
-    return names.length;
-}
-function validateHosts(hosts, config, issues) {
-    if (hosts === undefined)
-        return 0;
-    if (!Array.isArray(hosts)) {
-        issues.push({ path: 'hosts', message: 'hosts must be a list of host names' });
-        return 0;
-    }
-    hosts.forEach((host, i) => {
-        const path = `hosts[${i}]`;
-        if (typeof host !== 'string' || host.length === 0 || host.length > 253) {
-            issues.push({ path, message: 'host must be a non-empty string' });
-            return;
-        }
-        for (const match of host.matchAll(HOST_PLACEHOLDER)) {
-            const fieldPath = match[1] ?? '';
-            const fieldType = configFieldType(config, fieldPath);
-            if (!fieldType) {
-                issues.push({ path, message: `host template references undeclared config field ${fieldPath}` });
-            }
-            else if (fieldType.kind !== 'string') {
-                issues.push({ path, message: `host template field ${fieldPath} must be declared with t.string()` });
-            }
-        }
-        if (!HOST_PATTERN.test(host.replace(HOST_PLACEHOLDER, 'x'))) {
-            issues.push({ path, message: 'host must be an exact host name or *.suffix, without scheme, port or path' });
-        }
-    });
-    return hosts.length;
-}
-function validateRateLimit(rateLimit, issues) {
-    if (rateLimit === undefined)
-        return;
-    if (!isRecord(rateLimit)) {
-        issues.push({ path: 'rateLimit', message: 'rateLimit must be { perSecond, concurrency }' });
-        return;
-    }
-    const { perSecond, concurrency } = rateLimit;
-    if (typeof perSecond !== 'number' || !Number.isFinite(perSecond) || perSecond <= 0) {
-        issues.push({ path: 'rateLimit.perSecond', message: 'rateLimit.perSecond must be a positive number' });
-    }
-    if (!isPositiveInteger(concurrency)) {
-        issues.push({ path: 'rateLimit.concurrency', message: 'rateLimit.concurrency must be a positive integer' });
-    }
-}
-function validateStreams(streams, issues) {
-    if (streams === undefined)
-        return 0;
-    if (!isRecord(streams)) {
-        issues.push({ path: 'streams', message: 'streams must be an object of async generator functions' });
-        return 0;
-    }
-    for (const [name, stream] of Object.entries(streams)) {
-        const path = `streams.${name}`;
-        if (!SDK_NAME_PATTERN.test(name))
-            issues.push({ path, message: `stream name must match ${SDK_NAME_PATTERN.source}` });
-        if (typeof stream !== 'function')
-            issues.push({ path, message: `${path} must be an async generator function` });
-    }
-    return Object.keys(streams).length;
-}
-export function validateConnectorDefinition(definition) {
-    if (!isRecord(definition)) {
-        return [{ path: '', message: 'connector definition must be an object' }];
-    }
-    const issues = [];
-    if (typeof definition.name !== 'string' || !SDK_NAME_PATTERN.test(definition.name)) {
-        issues.push({ path: 'name', message: `name must match ${SDK_NAME_PATTERN.source}` });
-    }
-    if (typeof definition.version !== 'string' || !VERSION_PATTERN.test(definition.version)) {
-        issues.push({ path: 'version', message: 'version must be a semver string like 1.0.0' });
-    }
-    validateObjectDeclaration('config', definition.config, {
-        secretAllowed: true,
-        secretMessage: 'secret fields must be top-level config fields',
-    }, issues);
-    const hostCount = validateHosts(definition.hosts, definition.config, issues);
-    const hasDb = definition.db !== undefined;
-    if (hasDb && (!isRecord(definition.db) || definition.db.engine !== 'postgresql')) {
-        issues.push({ path: 'db.engine', message: "db.engine must be 'postgresql'" });
-    }
-    validateRateLimit(definition.rateLimit, issues);
-    if (definition.check !== undefined && typeof definition.check !== 'function') {
-        issues.push({ path: 'check', message: 'check must be a function' });
-    }
-    if (typeof definition.discover !== 'function') {
-        issues.push({ path: 'discover', message: 'discover must be a function' });
-    }
-    if (definition.writes !== undefined) {
-        issues.push({ path: 'writes', message: 'external write operations are not available yet' });
-    }
-    const streamCount = validateStreams(definition.streams, issues);
-    const pushCount = validatePush(definition.push, issues);
-    if (streamCount === 0 && pushCount === 0) {
-        issues.push({ path: 'streams', message: 'connector must declare at least one stream or push' });
-    }
-    if (streamCount > 0 && hostCount === 0 && !hasDb) {
-        issues.push({ path: 'hosts', message: 'connectors with streams must declare hosts (for ctx.http) or db (for ctx.db)' });
-    }
-    return issues;
-}
-function validateStreamDiscovery(path, stream, owners, issues) {
-    if (!isRecord(stream)) {
-        issues.push({ path, message: 'stream declaration must be an object' });
-        return;
-    }
-    validateTables(`${path}.tables`, stream.tables, owners, path, issues);
-    const syncModes = stream.syncModes;
-    if (!isStringArray(syncModes) || syncModes.length === 0 || !syncModes.every((mode) => SYNC_MODES.has(mode)) || new Set(syncModes).size !== syncModes.length) {
-        issues.push({ path: `${path}.syncModes`, message: "syncModes must be a non-empty list of 'full' and/or 'incremental'" });
-    }
-    if (stream.snapshot !== undefined && (typeof stream.snapshot !== 'string' || !SNAPSHOTS.has(stream.snapshot))) {
-        issues.push({ path: `${path}.snapshot`, message: "snapshot must be 'complete' or 'partial'" });
-    }
-    if (stream.params !== undefined) {
-        validateObjectDeclaration(`${path}.params`, stream.params, {
-            secretAllowed: false,
-            secretMessage: 'stream params cannot contain secret fields',
-        }, issues);
-    }
-}
-function definitionStreamNames(definition) {
-    if (!isRecord(definition) || !isRecord(definition.streams))
-        return [];
-    return Object.keys(definition.streams);
-}
-function definitionPushNames(definition) {
-    if (!isRecord(definition))
-        return [];
-    return pushNames(definition.push);
-}
-export function validateDiscoverResult(result, definition) {
-    if (!isRecord(result)) {
-        return [{ path: '', message: 'discover result must be an object' }];
-    }
-    const issues = [];
-    const owners = new Map();
-    const declaredStreams = definitionStreamNames(definition);
-    const streams = result.streams === undefined ? {} : result.streams;
-    if (!isRecord(streams)) {
-        issues.push({ path: 'streams', message: 'streams must be an object' });
-    }
-    else {
-        for (const [name, stream] of Object.entries(streams)) {
-            const path = `streams.${name}`;
-            if (!declaredStreams.includes(name)) {
-                issues.push({ path, message: `stream ${name} is not defined in the connector's streams` });
-            }
-            validateStreamDiscovery(path, stream, owners, issues);
-        }
-        for (const name of declaredStreams) {
-            if (!Object.hasOwn(streams, name)) {
-                issues.push({ path: `streams.${name}`, message: `stream ${name} is defined but missing from the discover result` });
-            }
-        }
-    }
-    const declaredPushes = definitionPushNames(definition);
-    const pushes = result.push === undefined ? {} : result.push;
-    if (!isRecord(pushes)) {
-        issues.push({ path: 'push', message: 'push must be an object of { tables } by push name' });
-    }
-    else {
-        for (const [name, push] of Object.entries(pushes)) {
-            const path = `push.${name}`;
-            if (!declaredPushes.includes(name)) {
-                issues.push({ path, message: `push ${name} is not defined in the connector's push handlers` });
-            }
-            if (!isRecord(push)) {
-                issues.push({ path, message: 'push declaration must be { tables }' });
-                continue;
-            }
-            validateTables(`${path}.tables`, push.tables, owners, path, issues);
-        }
-        for (const name of declaredPushes) {
-            if (!Object.hasOwn(pushes, name)) {
-                issues.push({ path: `push.${name}`, message: `push ${name} is defined but missing from the discover result` });
-            }
-        }
-    }
-    return issues;
-}
-export function normalizeDiscoverResult(result) {
-    const streams = {};
-    for (const [name, stream] of Object.entries(result.streams ?? {})) {
-        streams[name] = {
-            tables: stream.tables,
-            syncModes: [...stream.syncModes],
-            snapshot: stream.snapshot ?? 'partial',
-            ...(stream.params ? { params: stream.params } : {}),
-        };
-    }
-    const pushes = {};
-    for (const [name, push] of Object.entries(result.push ?? {}))
-        pushes[name] = { tables: push.tables };
-    return { streams, pushes };
-}
-function topLevelSecrets(config) {
-    if (!isRecord(config) || !isRecord(config.shape))
-        return [];
-    const secrets = [];
-    for (const [field, type] of Object.entries(config.shape)) {
-        if (isRecord(type) && type.kind === 'secret')
-            secrets.push({ field, exposeToScript: type.exposeToScript === true });
-    }
-    return secrets;
-}
-export function summarizeDefinition(definition) {
-    const secrets = topLevelSecrets(definition.config);
-    const rateLimit = definition.rateLimit;
-    return {
-        name: definition.name,
-        version: definition.version,
-        hosts: Array.isArray(definition.hosts) ? definition.hosts.filter((host) => typeof host === 'string') : [],
-        db: definition.db?.engine === 'postgresql' ? { engine: 'postgresql' } : null,
-        rateLimit: rateLimit ? { perSecond: rateLimit.perSecond, concurrency: rateLimit.concurrency } : null,
-        pushes: pushNames(definition.push),
-        streams: definitionStreamNames(definition),
-        secretFields: secrets.map((secret) => secret.field),
-        exposeToScript: secrets.filter((secret) => secret.exposeToScript).map((secret) => secret.field),
-        ...(isRecord(definition.config) ? { config: JSON.parse(JSON.stringify(definition.config)) } : {}),
-    };
-}
-function isValidDate(text) {
-    if (!DATE_PATTERN.test(text))
-        return false;
-    const date = new Date(`${text}T00:00:00Z`);
-    return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === text;
-}
-function validateValue(path, type, value, issues) {
-    if (!isRecord(type) || typeof type.kind !== 'string') {
-        issues.push({ path, message: 'field type is not a valid t.*() declaration' });
-        return;
-    }
-    const fail = (expected) => issues.push({ path, message: `${path} must be ${expected}` });
-    switch (type.kind) {
-        case 'string':
-            if (typeof value !== 'string')
-                fail('a string');
-            return;
-        case 'integer':
-            if (typeof value !== 'number' || !Number.isSafeInteger(value))
-                fail('an integer');
-            return;
-        case 'decimal':
-            if (!(typeof value === 'number' && Number.isFinite(value)) && !(typeof value === 'string' && DECIMAL_TEXT_PATTERN.test(value)))
-                fail('a decimal number');
-            return;
-        case 'boolean':
-            if (typeof value !== 'boolean')
-                fail('a boolean');
-            return;
-        case 'date':
-            if (typeof value !== 'string' || !isValidDate(value))
-                fail('a date like 2026-01-31');
-            return;
-        case 'instant':
-            if (typeof value !== 'string' || !INSTANT_PATTERN.test(value) || Number.isNaN(Date.parse(value)))
-                fail('an ISO 8601 timestamp with time zone');
-            return;
-        case 'json':
-            return;
-        case 'object':
-            if (!isRecord(value)) {
-                fail('an object');
-                return;
-            }
-            validateFields(path, type, value, issues, false);
-            return;
-        case 'array':
-            if (!Array.isArray(value)) {
-                fail('an array');
-                return;
-            }
-            value.forEach((item, i) => {
-                if (item === undefined || item === null)
-                    issues.push({ path: `${path}[${i}]`, message: `${path}[${i}] is required` });
-                else
-                    validateValue(`${path}[${i}]`, type.item, item, issues);
-            });
-            return;
-        case 'secret':
-            issues.push({ path, message: 'secret fields must be top-level config fields' });
-            return;
-        default:
-            issues.push({ path, message: `unknown type kind ${type.kind}` });
-    }
-}
-function validateFields(path, type, value, issues, topLevel) {
-    const shape = isRecord(type.shape) ? type.shape : {};
-    for (const [field, fieldType] of Object.entries(shape)) {
-        const fieldPath = `${path}.${field}`;
-        if (topLevel && isRecord(fieldType) && fieldType.kind === 'secret')
-            continue;
-        const fieldValue = value[field];
-        if (fieldValue === undefined || fieldValue === null) {
-            if (!(isRecord(fieldType) && fieldType.kind === 'json' && fieldValue === null)) {
-                issues.push({ path: fieldPath, message: `${fieldPath} is required` });
-            }
-            continue;
-        }
-        validateValue(fieldPath, fieldType, fieldValue, issues);
-    }
-    for (const field of Object.keys(value)) {
-        if (!Object.hasOwn(shape, field))
-            issues.push({ path: `${path}.${field}`, message: `${path}.${field} is not declared` });
-    }
-}
-export function validateConfig(schema, config) {
-    if (!isRecord(config))
-        return [{ path: 'config', message: 'config must be an object' }];
-    const issues = [];
-    validateFields('config', schema, config, issues, true);
-    return issues;
-}