@async/db 0.2.0

package/dist/features/schema/resolvers.js

@@ -0,0 +1,111 @@
+export function createResolverContext(internal = {}, provided = {}) {
+    const internalMap = normalizeContextMap(internal);
+    const services = internalMap.get('services');
+    if (services && typeof services === 'object' && !Array.isArray(services)) {
+        for (const [key, value] of Object.entries(services)) {
+            if (!internalMap.has(key)) {
+                internalMap.set(key, value);
+            }
+        }
+    }
+    const providedMap = normalizeContextMap(provided);
+    const context = {
+        get(key) {
+            return providedMap.has(key) ? providedMap.get(key) : internalMap.get(key);
+        },
+        has(key) {
+            return providedMap.has(key) || internalMap.has(key);
+        },
+    };
+    Object.defineProperty(context, '_internal', {
+        enumerable: false,
+        value: createInternalView(internalMap),
+    });
+    for (const key of new Set([...internalMap.keys(), ...providedMap.keys()])) {
+        if (key in context) {
+            continue;
+        }
+        Object.defineProperty(context, key, {
+            enumerable: true,
+            get() {
+                return context.get(key);
+            },
+        });
+    }
+    return context;
+}
+export async function callFieldResolver(resolver, args, options = {}) {
+    const value = options.value ?? args?.record ?? args?.records ?? args?.value;
+    const db = options.db;
+    const config = options.config;
+    const resolverThis = createResolverContext({
+        db: options.db,
+        config: options.config ?? db?.config,
+        resource: options.resource,
+        field: options.resource?.fields?.[options.fieldName],
+        fieldName: options.fieldName,
+        cache: options.cache,
+        services: options.services ?? config?.services ?? db?.config?.services ?? {},
+        value,
+        record: args?.record ?? value,
+        records: args?.records,
+        args,
+    }, options.context);
+    return resolver.call(resolverThis, args);
+}
+export function valueFromResolveManyResult(values, resource, record, index = 0) {
+    if (Array.isArray(values)) {
+        return values[index];
+    }
+    if (values instanceof Map) {
+        const key = keyForRecord(record, resource, index);
+        return values.get(key) ?? values.get(String(key)) ?? values.get(index);
+    }
+    if (values && typeof values === 'object') {
+        const key = keyForRecord(record, resource, index);
+        const recordValues = values;
+        return recordValues[key] ?? recordValues[String(key)] ?? recordValues[index];
+    }
+    return undefined;
+}
+function createInternalView(internalMap) {
+    const view = {
+        get(key) {
+            return internalMap.get(key);
+        },
+        has(key) {
+            return internalMap.has(key);
+        },
+    };
+    for (const key of internalMap.keys()) {
+        if (key in view) {
+            continue;
+        }
+        Object.defineProperty(view, key, {
+            enumerable: true,
+            get() {
+                return internalMap.get(key);
+            },
+        });
+    }
+    return Object.freeze(view);
+}
+function normalizeContextMap(value) {
+    if (value instanceof Map) {
+        return new Map(value);
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return new Map();
+    }
+    return new Map(Object.entries(value));
+}
+function keyForRecord(record, resource, index) {
+    if (resource?.kind === 'collection') {
+        const idField = resource.idField ?? 'id';
+        const id = record?.[idField];
+        if (id !== undefined && id !== null && id !== '') {
+            return id;
+        }
+    }
+    return index;
+}

package/dist/features/schema/resource.d.ts

@@ -0,0 +1,75 @@
+import { type SchemaField } from './fields.js';
+import { relationsForResource } from './relations.js';
+import { normalizeFilesSource, type FilesSourceDefinition } from './source-definitions.js';
+import { type SchemaDiagnostic } from './standard-schema.js';
+type ResourceKind = 'collection' | 'document';
+type ResourceConfig = {
+    idField?: string;
+    [key: string]: unknown;
+};
+type SchemaBuildConfig = {
+    collections?: Record<string, ResourceConfig>;
+    [key: string]: unknown;
+};
+type RawSchema = {
+    kind?: ResourceKind;
+    idField?: string;
+    description?: string;
+    seed?: unknown;
+    fields?: Record<string, unknown>;
+    validator?: unknown;
+    standardSchema?: unknown;
+    source?: Parameters<typeof normalizeFilesSource>[0];
+    parser?: string;
+    store?: unknown;
+    [key: string]: unknown;
+};
+type BuildResourceInput = {
+    name: string;
+    dataPath?: string | null;
+    dataFormat?: string | null;
+    dataHash?: string | null;
+    schemaPath?: string | null;
+    schemaSource?: string | null;
+    rawData?: unknown;
+    rawSchema?: RawSchema | null;
+    config: SchemaBuildConfig;
+    includeSeed?: boolean;
+};
+type FieldResolver = (...args: unknown[]) => unknown;
+type RawResolverField = {
+    resolve?: FieldResolver;
+    resolveMany?: FieldResolver;
+};
+type ResourceResolvers = {
+    fields: Record<string, RawResolverField>;
+};
+type BuiltResource = {
+    name: string;
+    kind: ResourceKind;
+    idField: string;
+    description?: string;
+    fields: Record<string, SchemaField>;
+    seed: unknown;
+    dataPath?: string | null;
+    dataFormat?: string | null;
+    dataHash?: string | null;
+    schemaPath?: string | null;
+    schemaSource: string | null;
+    schemaHasSeed?: boolean;
+    schemaSeed?: unknown;
+    typeSource: 'schema' | 'data';
+    generatedIds: boolean;
+    resolvers: ResourceResolvers;
+    validators: Record<string, unknown>;
+    validatorSource?: string;
+    fieldsAuthoritative: boolean;
+    typeFallback?: string;
+    diagnostics?: SchemaDiagnostic[];
+    source?: FilesSourceDefinition | null;
+    typeName?: string;
+    routePath?: string;
+    relations?: ReturnType<typeof relationsForResource>;
+};
+export declare function buildResource({ name, dataPath, dataFormat, dataHash, schemaPath, schemaSource, rawData, rawSchema, config, includeSeed, }: BuildResourceInput): BuiltResource;
+export {};

package/dist/features/schema/resource.js

@@ -0,0 +1,253 @@
+import { resourceConfigValue, routePathForResource, typeNameForResource } from '../../names.js';
+import { inferFieldsFromData, normalizeField } from './fields.js';
+import { relationsForResource } from './relations.js';
+import { normalizeFilesSource } from './source-definitions.js';
+import { mergeStandardSchemaFields, standardJsonSchemaFields } from './standard-schema.js';
+export function buildResource({ name, dataPath, dataFormat, dataHash, schemaPath, schemaSource, rawData, rawSchema, config, includeSeed = true, }) {
+    const collectionConfig = resourceConfigValue(config.collections, name) ?? {};
+    if (rawSchema) {
+        const kind = rawSchema.kind ?? inferKindFromData(rawData) ?? 'collection';
+        const idField = rawSchema.idField ?? collectionConfig.idField ?? 'id';
+        const schemaHasSeed = Object.prototype.hasOwnProperty.call(rawSchema, 'seed');
+        const schemaSeed = includeSeed && schemaHasSeed ? rawSchema.seed : emptySeedForKind(kind);
+        const seed = includeSeed && rawData !== undefined ? rawData : schemaSeed;
+        const standardSchema = rawSchema.validator ?? rawSchema.standardSchema;
+        const standardSchemaSource = rawSchema.validator ? 'validator' : rawSchema.standardSchema ? 'standardSchema' : undefined;
+        const standardFields = standardSchema
+            ? standardJsonSchemaFields(standardSchema, name)
+            : { fields: {}, authoritative: true, diagnostics: [] };
+        const rawFields = standardSchema
+            ? mergeStandardSchemaFields(standardFields.fields, rawSchema.fields ?? {})
+            : rawSchema.fields ?? {};
+        const standardDiagnostics = standardSchema && Object.keys(rawFields).length === 0
+            ? standardFields.diagnostics
+            : [];
+        const resolvers = resolversForFieldMap(rawFields);
+        let fields = Object.fromEntries(Object.entries(rawFields).map(([fieldName, field]) => [fieldName, normalizeField(field, fieldName)]));
+        if (kind === 'collection') {
+            fields = ensureCollectionIdField(fields, idField);
+        }
+        const normalizedSeed = normalizeSeed(dataFormat === 'csv' ? coerceCsvSeedToSchema(seed, fields, kind) : seed, kind);
+        const idResult = ensureCollectionSeedIds(normalizedSeed, kind, idField);
+        const normalizedSchemaSeed = includeSeed && schemaHasSeed
+            ? ensureCollectionSeedIds(normalizeSeed(schemaSeed, kind), kind, idField).seed
+            : undefined;
+        return withComputedMetadata({
+            name,
+            kind,
+            idField,
+            description: rawSchema.description,
+            fields,
+            seed: idResult.seed,
+            dataPath,
+            dataFormat,
+            dataHash,
+            schemaPath,
+            schemaSource: schemaSource ?? null,
+            schemaHasSeed,
+            schemaSeed: normalizedSchemaSeed,
+            typeSource: 'schema',
+            generatedIds: idResult.generated,
+            resolvers,
+            validators: standardSchema ? { standard: standardSchema } : {},
+            validatorSource: standardSchemaSource,
+            fieldsAuthoritative: standardSchema ? standardFields.authoritative : true,
+            typeFallback: standardSchema && Object.keys(rawFields).length === 0 ? 'record' : undefined,
+            diagnostics: standardDiagnostics,
+            source: normalizeFilesSource(rawSchema.source, { read: rawSchema.parser }),
+        });
+    }
+    const kind = inferKindFromData(rawData);
+    const idField = collectionConfig.idField ?? inferIdField(rawData, kind);
+    const normalizedSeed = normalizeSeed(rawData, kind);
+    const idResult = ensureCollectionSeedIds(normalizedSeed, kind, idField);
+    const fields = kind === 'collection'
+        ? ensureCollectionIdField(inferFieldsFromData(idResult.seed, kind), idField)
+        : inferFieldsFromData(idResult.seed, kind);
+    return withComputedMetadata({
+        name,
+        kind,
+        idField,
+        fields,
+        seed: idResult.seed,
+        dataPath,
+        dataFormat,
+        dataHash,
+        schemaPath,
+        schemaSource: null,
+        typeSource: 'data',
+        generatedIds: idResult.generated,
+        resolvers: { fields: {} },
+        validators: {},
+        fieldsAuthoritative: true,
+    });
+}
+function resolversForFieldMap(fields) {
+    const resolvers = {};
+    for (const [fieldName, field] of Object.entries(fields ?? {})) {
+        if (!isPlainRecord(field)) {
+            continue;
+        }
+        const resolver = {};
+        if (typeof field.resolve === 'function') {
+            resolver.resolve = field.resolve;
+        }
+        if (typeof field.resolveMany === 'function') {
+            resolver.resolveMany = field.resolveMany;
+        }
+        if (Object.keys(resolver).length > 0) {
+            resolvers[fieldName] = resolver;
+        }
+    }
+    return { fields: resolvers };
+}
+function coerceCsvSeedToSchema(seed, fields, kind) {
+    if (kind === 'collection') {
+        return Array.isArray(seed)
+            ? seed.map((record) => coerceCsvRecordToSchema(record, fields))
+            : seed;
+    }
+    return coerceCsvRecordToSchema(seed, fields);
+}
+function coerceCsvRecordToSchema(record, fields) {
+    if (!isPlainRecord(record)) {
+        return record;
+    }
+    const next = { ...record };
+    for (const [fieldName, field] of Object.entries(fields ?? {})) {
+        if (field.type === 'array' && typeof next[fieldName] === 'string') {
+            next[fieldName] = parseCsvArrayValue(next[fieldName], field.items ?? { type: 'unknown' });
+        }
+    }
+    return next;
+}
+function parseCsvArrayValue(value, itemField) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed.map((item) => coerceCsvArrayItem(item, itemField));
+            }
+        }
+        catch {
+            return value;
+        }
+    }
+    return trimmed
+        .split(';')
+        .map((item) => item.trim())
+        .filter((item) => item !== '')
+        .map((item) => coerceCsvArrayItem(item, itemField));
+}
+function coerceCsvArrayItem(value, itemField) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    if (itemField.type === 'number' && /^[+-]?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) {
+        return Number(value);
+    }
+    if (itemField.type === 'boolean') {
+        const lower = value.toLowerCase();
+        if (lower === 'true') {
+            return true;
+        }
+        if (lower === 'false') {
+            return false;
+        }
+    }
+    return value;
+}
+function withComputedMetadata(resource) {
+    const next = {
+        ...resource,
+        typeName: typeNameForResource(resource.name, resource.kind),
+        routePath: routePathForResource(resource.name),
+    };
+    next.relations = relationsForResource(next);
+    return next;
+}
+function inferKindFromData(data) {
+    return Array.isArray(data) ? 'collection' : 'document';
+}
+function inferIdField(data, kind) {
+    if (kind !== 'collection' || !Array.isArray(data) || data.length === 0) {
+        return 'id';
+    }
+    if (data.every((record) => isPlainRecord(record) && 'id' in record)) {
+        return 'id';
+    }
+    const firstRecord = data.find((record) => isPlainRecord(record));
+    return Object.keys(firstRecord ?? {}).find((fieldName) => /id$/i.test(fieldName)) ?? 'id';
+}
+function ensureCollectionIdField(fields, idField) {
+    if (idField in fields) {
+        return fields;
+    }
+    return {
+        [idField]: {
+            type: 'string',
+            required: true,
+            description: 'Generated local id.',
+        },
+        ...fields,
+    };
+}
+function ensureCollectionSeedIds(seed, kind, idField) {
+    if (kind !== 'collection' || !Array.isArray(seed)) {
+        return {
+            seed,
+            generated: false,
+        };
+    }
+    const usedIds = new Set(seed
+        .map((record) => isPlainRecord(record) ? record[idField] : undefined)
+        .filter((id) => id !== undefined && id !== null && id !== '')
+        .map((id) => String(id)));
+    let nextId = nextCounterId(usedIds);
+    let generated = false;
+    const records = seed.map((record) => {
+        if (!isPlainRecord(record) || (record[idField] !== undefined && record[idField] !== null && record[idField] !== '')) {
+            return record;
+        }
+        generated = true;
+        while (usedIds.has(String(nextId))) {
+            nextId += 1;
+        }
+        const id = String(nextId);
+        usedIds.add(id);
+        nextId += 1;
+        return {
+            [idField]: id,
+            ...record,
+        };
+    });
+    return {
+        seed: records,
+        generated,
+    };
+}
+function nextCounterId(usedIds) {
+    const numericIds = [...usedIds]
+        .map((id) => Number(id))
+        .filter((id) => Number.isInteger(id) && id > 0);
+    if (numericIds.length > 0) {
+        return Math.max(...numericIds) + 1;
+    }
+    return 1;
+}
+function normalizeSeed(seed, kind) {
+    if (kind === 'collection') {
+        return Array.isArray(seed) ? seed : [];
+    }
+    if (isPlainRecord(seed)) {
+        return seed;
+    }
+    return {};
+}
+function emptySeedForKind(kind) {
+    return kind === 'collection' ? [] : {};
+}
+function isPlainRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/features/schema/source-definitions.d.ts

@@ -0,0 +1,21 @@
+type FilesSourceInput = string | readonly string[] | {
+    kind?: string;
+    patterns?: string | readonly string[];
+    pattern?: string | readonly string[];
+    glob?: string | readonly string[];
+    source?: string | readonly string[];
+    read?: string;
+};
+export type FilesSourceDefinition = {
+    kind: 'files';
+    patterns: string[];
+    read: string;
+};
+type FilesSourceOptions = {
+    read?: string;
+};
+export declare function normalizeFilesSource(source: FilesSourceInput | null | undefined, options?: FilesSourceOptions): FilesSourceDefinition | null;
+export declare function isFilesSource(value: unknown): value is Extract<FilesSourceInput, {
+    kind?: string;
+}>;
+export {};

package/dist/features/schema/source-definitions.js

@@ -0,0 +1,29 @@
+export function normalizeFilesSource(source, options = {}) {
+    if (!source) {
+        return null;
+    }
+    if (isFilesSource(source)) {
+        return {
+            kind: 'files',
+            patterns: normalizePatterns(source.patterns ?? source.pattern ?? source.glob ?? source.source),
+            read: source.read ?? options.read ?? 'frontmatter',
+        };
+    }
+    return {
+        kind: 'files',
+        patterns: normalizePatterns(source),
+        read: options.read ?? 'frontmatter',
+    };
+}
+export function isFilesSource(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value) && value.kind === 'files';
+}
+function normalizePatterns(value) {
+    if (Array.isArray(value)) {
+        return value.map(String);
+    }
+    if (value === undefined || value === null) {
+        return [];
+    }
+    return [String(value)];
+}

package/dist/features/schema/sources.d.ts

@@ -0,0 +1,83 @@
+import { resourceNameFromPath } from '../../config-public.js';
+type SourceKind = 'data' | 'schema';
+type ResourceNamingStrategy = Parameters<typeof resourceNameFromPath>[1]['strategy'] | string;
+type SchemaDiagnostic = {
+    code: string;
+    severity: 'error' | 'warn' | 'info';
+    resource?: string;
+    file?: string;
+    message: string;
+    hint?: string;
+    details?: Record<string, unknown>;
+};
+type SchemaLocator = {
+    mode?: 'project' | 'root-schema' | 'schema-file' | 'source-dir' | string;
+    file?: string | null;
+    [key: string]: unknown;
+};
+type SchemaConfig = {
+    cwd?: string;
+    sourceDir?: string;
+    schema?: {
+        source?: 'data' | 'schema' | string;
+        allowJsonc?: boolean;
+        autoModulePackageJson?: boolean;
+        [key: string]: unknown;
+    };
+    schemaLocator?: SchemaLocator | null;
+    operations?: {
+        sourceDir?: string;
+        [key: string]: unknown;
+    };
+    resources?: {
+        naming?: ResourceNamingStrategy;
+        customizeResource?: (context: ResourceCustomizeContext) => unknown;
+        [key: string]: unknown;
+    };
+    sources?: {
+        readers?: unknown[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+type SourceFileListConfig = {
+    sourceDir?: string;
+    operations?: SchemaConfig['operations'];
+};
+type SourceRecord = {
+    kind: SourceKind;
+    name: string;
+    file: string;
+    sourceFile: string;
+    format: string;
+    hash?: string;
+    data?: unknown;
+    schema?: unknown;
+    baseDir?: string;
+};
+type SourceReadResult = {
+    sources: SourceRecord[];
+    diagnostics: SchemaDiagnostic[];
+};
+type RootSchemaReadResult = SourceReadResult & {
+    found: boolean;
+    file?: string | null;
+};
+type ResourceCustomizeContext = {
+    file: string;
+    sourceFile: string;
+    basename: string;
+    folder: string | null;
+    folders: string[];
+    extension: string;
+    defaultName: string;
+    defaultResource: {
+        name: string;
+    };
+};
+export declare function listSourceFiles(sourceDirOrConfig: string | SourceFileListConfig): Promise<string[]>;
+export declare function readRootSchemaFile(config: SchemaConfig): Promise<RootSchemaReadResult>;
+export declare function readSourceFile(config: SchemaConfig, filename: string): Promise<SourceReadResult>;
+export declare function trackResourceSource(resourceSources: Map<string, unknown>, name: string, filename: string, kind: SourceKind): void;
+export declare function duplicateResourceDiagnostics(resourceSources: Map<string, unknown>): SchemaDiagnostic[];
+export {};