@agentshouse/mdruntime 0.1.0-alpha.24 → 0.1.0-alpha.25

package/dist/query.d.ts

@@ -1,13 +1,202 @@
-import type { QueryOptions, QueryResult } from '@agentshouse/query';
-import type { Document } from '@agentshouse/mdmodel';
-import type { TypesResult } from './model.js';
-export type QueryInput = {
+import type { Definition } from '@agentshouse/mdmodel';
+export type Value = string | number | boolean | null;
+export type Predicate = Value | {
+    $eq: Value;
+} | {
+    $ne: Value;
+} | {
+    $in: readonly Value[];
+} | {
+    $nin: readonly Value[];
+} | {
+    $gt?: Value;
+    $gte?: Value;
+    $lt?: Value;
+    $lte?: Value;
+} | {
+    $all: readonly Value[];
+} | {
+    $size: number;
+} | {
+    $exists: boolean;
+};
+export type Where = {
+    $and?: readonly Where[];
+    $or?: readonly Where[];
+    [field: string]: Predicate | readonly Where[] | undefined;
+};
+export type Related = {
+    types?: readonly string[];
+    where?: Where;
+    pathPrefix?: string;
+};
+export type Filter = {
+    rooms?: readonly string[];
+    types?: readonly string[];
+    where?: Where;
+    pathPrefix?: string;
+    hop?: Related & {
+        field: string;
+    };
+    backlinks?: Related & {
+        field?: string;
+    };
+};
+export type Key = 'room' | 'path' | 'type' | {
+    field: string;
+};
+export type Select = 'all' | {
+    fields?: 'all' | readonly string[];
+    sections?: 'all' | readonly string[];
+    preamble?: true;
+    markdown?: true;
+    backlinks?: true;
+};
+export type OrderOptions = {
+    nulls?: 'first' | 'last';
+    stringSort?: 'lexical' | 'locale';
+    locale?: string;
+    localeOptions?: Readonly<Record<string, unknown>>;
+};
+export type Direction = 'asc' | 'desc';
+export type DocumentQuery = Filter & {
+    select: Select;
+    orderBy?: readonly ({
+        by: Key;
+        direction?: Direction;
+    } & OrderOptions)[];
+    limit?: number;
+};
+export type GroupQuery = Filter & {
+    groupBy: readonly Exclude<Key, 'path'>[];
+    orderBy?: readonly {
+        by: 'count' | Exclude<Key, 'path'>;
+        direction?: Direction;
+    }[];
+    limit?: number;
+};
+export type LocalQuery = DocumentQuery | GroupQuery;
+export type Backlink = {
+    path: string;
+    type: string;
+    field: string;
+};
+export type QueryDocument = {
     room: string;
-    roomVersion: string;
-    documents: Readonly<Record<string, Document>>;
-    model: TypesResult;
-    typedSelection: TypesResult | null;
+    path: string;
+    type: string;
+    fields?: Readonly<Record<string, unknown>>;
+    sections?: Readonly<Record<string, string>>;
+    preamble?: string;
+    markdown?: string;
+    backlinks?: readonly Backlink[];
+};
+export type QueryGroup = {
+    key: readonly unknown[];
+    count: number;
+};
+export type DocumentResult = {
+    documents: readonly QueryDocument[];
+};
+export type GroupResult = {
+    groups: readonly QueryGroup[];
+};
+export type QueryResult = DocumentResult | GroupResult;
+export type QueryErrorCode = 'invalid-query' | 'unknown-type' | 'unknown-field' | 'wrong-kind';
+export type RoomFacts = {
+    locator: string;
+    available: boolean;
+    types: readonly Definition[];
+};
+export type HeldRooms = {
+    listed: boolean;
+    rooms: readonly RoomFacts[];
+};
+export type Test = {
+    op: 'eq';
+    value: Value;
+} | {
+    op: 'ne';
+    value: Value;
+} | {
+    op: 'in';
+    values: readonly Value[];
+} | {
+    op: 'nin';
+    values: readonly Value[];
+} | {
+    op: 'range';
+    bounds: readonly (readonly ['gt' | 'gte' | 'lt' | 'lte', Value])[];
+} | {
+    op: 'all';
+    values: readonly Value[];
+} | {
+    op: 'size';
+    size: number;
+} | {
+    op: 'exists';
+    exists: boolean;
+};
+export type Condition = {
+    every: readonly Condition[];
+} | {
+    some: readonly Condition[];
+} | {
+    field: string;
+    test: Test;
+};
+export type Scope = {
+    types: readonly string[] | null;
+    where: Condition | null;
+    pathPrefix: string | null;
+};
+export type KeyPlan = {
+    of: 'room';
+} | {
+    of: 'path';
+} | {
+    of: 'type';
+} | {
+    of: 'field';
+    field: string;
+};
+export type DocumentShape = {
+    kind: 'documents';
+    fields: 'all' | readonly string[] | null;
+    sections: 'all' | readonly string[] | null;
+    preamble: boolean;
+    markdown: boolean;
+    backlinks: boolean;
+    orderBy: readonly {
+        key: KeyPlan;
+        options: OrderOptions & {
+            direction: Direction;
+        };
+    }[];
+};
+export type GroupShape = {
+    kind: 'groups';
+    groupBy: readonly KeyPlan[];
+    orderBy: readonly {
+        by: 'count' | number;
+        direction: Direction;
+    }[];
+};
+export type Plan = {
+    rooms: readonly string[] | null;
+    root: Scope;
+    hop: (Scope & {
+        field: string;
+    }) | null;
+    backlinks: (Scope & {
+        field: string | null;
+    }) | null;
+    shape: DocumentShape | GroupShape;
+    limit: number | null;
 };
-export type QueryBinding = (rooms: readonly QueryInput[], options: QueryOptions) => QueryResult;
-export declare function rawQuery(rooms: readonly QueryInput[]): QueryResult;
+export declare class QueryError extends Error {
+    constructor(code: QueryErrorCode, at: string, problem: string);
+}
+export declare function planOf(input: unknown, facts: HeldRooms): Plan;
+export declare function identityOf(plan: Plan): string;
 //# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC9C,KAAK,EAAE,WAAW,CAAC;IACnB,cAAc,EAAE,WAAW,GAAG,IAAI,CAAC;CACpC,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,EAAE,OAAO,EAAE,YAAY,KAAK,WAAW,CAAC;AAChG,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,WAAW,CAgBlE"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"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"}

package/dist/query.js

@@ -1,18 +1,454 @@
-export function rawQuery(rooms) {
-    return {
-        roomVersions: Object.fromEntries(rooms.map((room)=>[
-                room.room,
-                room.roomVersion
-            ])),
-        groups: null,
-        documents: rooms.flatMap((room)=>Object.entries(room.documents).filter(([path])=>path.endsWith('.md')).map(([path, document])=>({
-                    ...structuredClone(document),
-                    type: document.type ?? 'any',
-                    room: room.room,
-                    path,
-                    backlinks: []
-                })))
+import { normalize } from './paths.js';
+export class QueryError extends Error {
+    constructor(code, at, problem){
+        super(`${code} at ${at}: ${problem}`);
+    }
+}
+const RANGE = [
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte'
+];
+const SINGLE = [
+    '$eq',
+    '$ne',
+    '$in',
+    '$nin',
+    '$all',
+    '$size',
+    '$exists'
+];
+const FILTER = [
+    'rooms',
+    'types',
+    'where',
+    'pathPrefix',
+    'hop',
+    'backlinks',
+    'orderBy',
+    'limit'
+];
+const RELATED = [
+    'types',
+    'where',
+    'pathPrefix',
+    'field'
+];
+const PARTS = [
+    'fields',
+    'sections',
+    'preamble',
+    'markdown',
+    'backlinks'
+];
+const ORDER = [
+    'by',
+    'direction',
+    'nulls',
+    'stringSort',
+    'locale',
+    'localeOptions'
+];
+const CALENDAR_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function invalid(at, problem) {
+    throw new QueryError('invalid-query', at, problem);
+}
+function place(at, name) {
+    return at === '' ? name : `${at}.${name}`;
+}
+function plain(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function known(value, allowed, at) {
+    for (const name of Object.keys(value)){
+        if (!allowed.includes(name)) invalid(place(at, name), 'unknown part');
+    }
+}
+function list(input, at) {
+    if (!Array.isArray(input)) invalid(at, 'expects a list');
+    return input;
+}
+function value(input, at) {
+    if (Array.isArray(input)) invalid(at, 'a list is not a value');
+    if (input !== null && typeof input !== 'string' && typeof input !== 'boolean' && !(typeof input === 'number' && Number.isFinite(input))) {
+        invalid(at, 'not a value');
+    }
+    return input;
+}
+function values(input, at) {
+    return list(input, at).map((item, index)=>value(item, `${at}[${index}]`));
+}
+function names(input, at) {
+    const listed = list(input, at);
+    if (listed.some((item)=>typeof item !== 'string')) invalid(at, 'expects a list of names');
+    return [
+        ...new Set(listed)
+    ].sort();
+}
+function directory(input, at) {
+    if (typeof input !== 'string' || normalize(input) !== input) {
+        invalid(at, 'expects a normalized directory');
+    }
+    return input;
+}
+function calendarDate(value) {
+    const match = CALENDAR_DATE.exec(value);
+    if (match === null) return false;
+    const [year, month, day] = match.slice(1).map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function fits(spec, value) {
+    const item = spec.kind === 'list' ? spec.of : spec;
+    if (item.kind === 'number') return typeof value === 'number';
+    if (typeof value !== 'string') return false;
+    if (item.kind === 'enum') return item.values.includes(value);
+    if (item.kind === 'date') return calendarDate(value);
+    if (item.kind === 'reference') return value !== '' && normalize(value) === value;
+    return true;
+}
+function reference(spec) {
+    return spec.kind === 'reference' || spec.kind === 'list' && spec.of.kind === 'reference';
+}
+function typing(facts, rooms, types, at) {
+    const read = rooms === null ? facts.rooms : facts.rooms.filter((room)=>rooms.includes(room.locator));
+    const acquiring = !facts.listed && (rooms === null || rooms.some((locator)=>!facts.rooms.some((room)=>room.locator === locator)));
+    const available = !acquiring && read.every((room)=>room.available);
+    const declared = read.flatMap((room)=>room.types);
+    for (const name of types ?? []){
+        if (name === 'any' || !available || declared.some((type)=>type.name === name)) continue;
+        throw new QueryError('unknown-type', place(at, 'types'), `no model it reads declares ${name}`);
+    }
+    return {
+        untyped: types === null || types.includes('any') || !available,
+        types: types === null ? declared : declared.filter((type)=>types.includes(type.name))
+    };
+}
+function specs(typed, field, at) {
+    const declared = typed.types.flatMap((type)=>Object.hasOwn(type.fields, field) ? [
+            type.fields[field]
+        ] : []);
+    if (declared.length === 0 && !typed.untyped) {
+        throw new QueryError('unknown-field', at, `no MD Type it reads declares ${field}`);
+    }
+    return declared;
+}
+function kind(declared, checked, at) {
+    if (checked === null || declared.length === 0 || declared.some((spec)=>fits(spec, checked))) {
+        return;
+    }
+    throw new QueryError('wrong-kind', at, `${JSON.stringify(checked)} is not of its field's kind`);
+}
+function listed(declared, list) {
+    return declared.length > 0 && declared.every((spec)=>spec.kind === 'list' === list);
+}
+function test(declared, input, at) {
+    if (!plain(input)) {
+        const equal = value(input, at);
+        kind(declared, equal, at);
+        return {
+            op: 'eq',
+            value: equal
+        };
+    }
+    const operators = Object.keys(input);
+    if (operators.length === 0) invalid(at, 'names no operator');
+    if (operators.some((operator)=>RANGE.includes(operator))) {
+        const stray = operators.find((operator)=>!RANGE.includes(operator));
+        if (stray !== undefined) invalid(place(at, stray), 'cannot join a range');
+        if (listed(declared, true)) invalid(at, 'a range on a list');
+        return {
+            op: 'range',
+            bounds: RANGE.filter((operator)=>operators.includes(operator)).map((operator)=>{
+                const bound = value(input[operator], place(at, operator));
+                if (bound === null) invalid(place(at, operator), 'a range bound is never null');
+                kind(declared, bound, place(at, operator));
+                return [
+                    operator.slice(1),
+                    bound
+                ];
+            })
+        };
+    }
+    if (operators.length > 1) invalid(place(at, operators[1]), 'names a second operator');
+    const [operator] = operators;
+    const where = place(at, operator);
+    if (!SINGLE.includes(operator)) invalid(where, 'unknown operator');
+    const operand = input[operator];
+    if (operator === '$eq' || operator === '$ne') {
+        const compared = value(operand, where);
+        kind(declared, compared, where);
+        return operator === '$eq' ? {
+            op: 'eq',
+            value: compared
+        } : {
+            op: 'ne',
+            value: compared
+        };
+    }
+    if (operator === '$in' || operator === '$nin' || operator === '$all') {
+        const compared = values(operand, where);
+        compared.forEach((item, index)=>kind(declared, item, `${where}[${index}]`));
+        if (operator === '$in') return {
+            op: 'in',
+            values: compared
+        };
+        if (operator === '$nin') return {
+            op: 'nin',
+            values: compared
+        };
+        if (compared.includes(null)) invalid(where, 'a list holds no null');
+        if (listed(declared, false)) invalid(where, 'the field is not a list');
+        return {
+            op: 'all',
+            values: compared
+        };
+    }
+    if (operator === '$size') {
+        if (!Number.isSafeInteger(operand) || operand < 0) {
+            invalid(where, 'expects a nonnegative integer');
+        }
+        if (listed(declared, false)) invalid(where, 'the field is not a list');
+        return {
+            op: 'size',
+            size: operand
+        };
+    }
+    if (typeof operand !== 'boolean') invalid(where, 'expects true or false');
+    return {
+        op: 'exists',
+        exists: operand
     };
 }
+function condition(typed, input, at) {
+    if (!plain(input)) invalid(at, 'expects an object of field predicates');
+    const conditions = [];
+    for (const name of Object.keys(input).sort()){
+        const where = place(at, name);
+        const entry = input[name];
+        if (name === '$and' || name === '$or') {
+            const nested = list(entry, where).map((item, index)=>condition(typed, item, `${where}[${index}]`));
+            if (nested.length === 0) invalid(where, 'expects a nonempty list');
+            conditions.push(name === '$and' ? {
+                every: nested
+            } : {
+                some: nested
+            });
+            continue;
+        }
+        if (name.startsWith('$')) invalid(where, 'unknown operator');
+        conditions.push({
+            field: name,
+            test: test(specs(typed, name, where), entry, where)
+        });
+    }
+    if (conditions.length === 0) invalid(at, 'names no field');
+    return conditions.length === 1 ? conditions[0] : {
+        every: conditions
+    };
+}
+function scope(facts, rooms, input, at) {
+    const types = input.types === undefined ? null : names(input.types, place(at, 'types'));
+    const typed = typing(facts, rooms, types, at);
+    return {
+        typed,
+        types,
+        where: input.where === undefined || plain(input.where) && Object.keys(input.where).length === 0 ? null : condition(typed, input.where, place(at, 'where')),
+        pathPrefix: input.pathPrefix === undefined ? null : directory(input.pathPrefix, place(at, 'pathPrefix'))
+    };
+}
+function referenceField(typed, field, at) {
+    if (typeof field !== 'string') invalid(at, 'expects a field name');
+    const declared = specs(typed, field, at);
+    if (declared.length > 0 && !declared.some(reference)) invalid(at, 'not a reference field');
+    return field;
+}
+function hopOf(facts, rooms, root, input) {
+    if (!plain(input)) invalid('hop', 'expects an object');
+    known(input, RELATED, 'hop');
+    const field = referenceField(root, input.field, 'hop.field');
+    const { types, where, pathPrefix } = scope(facts, rooms, input, 'hop');
+    return {
+        types,
+        where,
+        pathPrefix,
+        field
+    };
+}
+function backlinksOf(facts, rooms, input) {
+    if (!plain(input)) invalid('backlinks', 'expects an object');
+    known(input, RELATED, 'backlinks');
+    const { typed, types, where, pathPrefix } = scope(facts, rooms, input, 'backlinks');
+    const field = input.field === undefined ? null : referenceField(typed, input.field, 'backlinks.field');
+    return {
+        types,
+        where,
+        pathPrefix,
+        field
+    };
+}
+function keyPlan(typed, input, at, path) {
+    if (input === 'room' || input === 'type' || path && input === 'path') return {
+        of: input
+    };
+    if (plain(input) && typeof input.field === 'string' && Object.keys(input).length === 1) {
+        specs(typed, input.field, place(at, 'field'));
+        return {
+            of: 'field',
+            field: input.field
+        };
+    }
+    return invalid(at, path ? 'expects room, path, type or a field' : 'expects room, type or a field');
+}
+function direction(input, at) {
+    if (input === undefined) return 'asc';
+    if (input !== 'asc' && input !== 'desc') invalid(at, 'expects asc or desc');
+    return input;
+}
+function orderOptions(input, at) {
+    const options = {
+        direction: direction(input.direction, place(at, 'direction'))
+    };
+    if (input.nulls !== undefined) {
+        if (input.nulls !== 'first' && input.nulls !== 'last') {
+            invalid(place(at, 'nulls'), 'expects first or last');
+        }
+        options.nulls = input.nulls;
+    }
+    if (input.stringSort !== undefined) {
+        if (input.stringSort !== 'lexical' && input.stringSort !== 'locale') {
+            invalid(place(at, 'stringSort'), 'expects lexical or locale');
+        }
+        options.stringSort = input.stringSort;
+    }
+    if (input.locale !== undefined) {
+        if (typeof input.locale !== 'string' || !collates(input.locale, undefined)) {
+            invalid(place(at, 'locale'), 'expects a locale name');
+        }
+        options.locale = input.locale;
+    }
+    if (input.localeOptions !== undefined) {
+        if (!plain(input.localeOptions) || !collates(options.locale, input.localeOptions)) {
+            invalid(place(at, 'localeOptions'), 'expects collation options');
+        }
+        options.localeOptions = input.localeOptions;
+    }
+    return options;
+}
+function collates(locale, options) {
+    try {
+        ''.localeCompare('', locale, options);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function parts(typed, input, at, fields) {
+    if (input === undefined) return null;
+    if (input === 'all') return 'all';
+    const named = list(input, at);
+    named.forEach((name, index)=>{
+        if (typeof name !== 'string') invalid(`${at}[${index}]`, 'expects a name');
+        if (fields) specs(typed, name, `${at}[${index}]`);
+    });
+    return named;
+}
+function flag(input, at) {
+    if (input === undefined) return false;
+    if (input !== true) invalid(at, 'expects true');
+    return true;
+}
+function documentShape(typed, input) {
+    const orderBy = (input.orderBy === undefined ? [] : list(input.orderBy, 'orderBy')).map((clause, index)=>{
+        const at = `orderBy[${index}]`;
+        if (!plain(clause)) invalid(at, 'expects an order clause');
+        known(clause, ORDER, at);
+        return {
+            key: keyPlan(typed, clause.by, place(at, 'by'), true),
+            options: orderOptions(clause, at)
+        };
+    });
+    const select = input.select;
+    if (select === 'all') {
+        return {
+            kind: 'documents',
+            fields: 'all',
+            sections: 'all',
+            preamble: true,
+            markdown: true,
+            backlinks: true,
+            orderBy
+        };
+    }
+    if (!plain(select)) invalid('select', "expects 'all' or the parts to return");
+    known(select, PARTS, 'select');
+    return {
+        kind: 'documents',
+        fields: parts(typed, select.fields, 'select.fields', true),
+        sections: parts(typed, select.sections, 'select.sections', false),
+        preamble: flag(select.preamble, 'select.preamble'),
+        markdown: flag(select.markdown, 'select.markdown'),
+        backlinks: flag(select.backlinks, 'select.backlinks'),
+        orderBy
+    };
+}
+function groupShape(typed, input) {
+    const groupBy = list(input.groupBy, 'groupBy').map((key, index)=>keyPlan(typed, key, `groupBy[${index}]`, false));
+    if (groupBy.length === 0) invalid('groupBy', 'names no key');
+    const grouped = groupBy.map((key)=>JSON.stringify(key));
+    const orderBy = (input.orderBy === undefined ? [] : list(input.orderBy, 'orderBy')).map((clause, index)=>{
+        const at = `orderBy[${index}]`;
+        if (!plain(clause)) invalid(at, 'expects an order clause');
+        known(clause, [
+            'by',
+            'direction'
+        ], at);
+        const by = clause.by === 'count' ? 'count' : grouped.indexOf(JSON.stringify(keyPlan(typed, clause.by, place(at, 'by'), false)));
+        if (by === -1) invalid(place(at, 'by'), 'orders by a key the query does not group by');
+        return {
+            by,
+            direction: direction(clause.direction, place(at, 'direction'))
+        };
+    });
+    return {
+        kind: 'groups',
+        groupBy,
+        orderBy
+    };
+}
+export function planOf(input, facts) {
+    if (!plain(input)) invalid('query', 'expects a query object');
+    const grouped = input.groupBy !== undefined;
+    if (grouped && input.select !== undefined) invalid('select', 'a grouped query selects nothing');
+    if (!grouped && input.select === undefined) invalid('select', 'a Document query must select');
+    known(input, [
+        ...FILTER,
+        grouped ? 'groupBy' : 'select'
+    ], '');
+    if (input.limit !== undefined && (!Number.isSafeInteger(input.limit) || input.limit < 0)) {
+        invalid('limit', 'expects a nonnegative integer');
+    }
+    const rooms = input.rooms === undefined ? null : names(input.rooms, 'rooms');
+    const { typed, ...root } = scope(facts, rooms, input, '');
+    return {
+        rooms,
+        root,
+        hop: input.hop === undefined ? null : hopOf(facts, rooms, typed, input.hop),
+        backlinks: input.backlinks === undefined ? null : backlinksOf(facts, rooms, input.backlinks),
+        shape: grouped ? groupShape(typed, input) : documentShape(typed, input),
+        limit: input.limit ?? null
+    };
+}
+function canonical(value) {
+    if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+    if (typeof value === 'object' && value !== null) {
+        return `{${Object.keys(value).sort().map((name)=>`${JSON.stringify(name)}:${canonical(value[name])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+export function identityOf(plan) {
+    return canonical(plan);
+}
 
 //# sourceMappingURL=query.js.map