@lovrozagar/oat 0.1.0

package/dist/reference/dialect.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The conventions a reference backend speaks.
+ *
+ * Everything oat had quietly hardcoded — what the page-size parameter is called, where the total
+ * lives in the envelope, how a filter expression is spelled — varies wildly between real APIs
+ * and not at all between two instances of the same fixture. A single-dialect fixture therefore
+ * proves that the checks work on *one* shape, which is a much weaker claim than it appears.
+ *
+ * Two dialects, differing in every name and in the filter grammar, turn that into a real test:
+ * the defects and the checks are identical, so anything that passes on one and fails on the
+ * other was reading a convention rather than the contract.
+ */
+export interface Dialect {
+    name: string;
+    /** Query parameter names, by role. */
+    params: {
+        filter: string;
+        order: string;
+        select: string;
+        search: string;
+        limit: string;
+        /** Page number, where the API counts pages. Absent when it counts rows skipped. */
+        page?: string;
+        /** Rows to skip, where the API pages by offset rather than page number. */
+        offset?: string;
+        cursor?: string;
+    };
+    /**
+     * Envelope property names, by role.
+     *
+     * `null` for the whole object means the response *is* the array and pagination facts travel in
+     * a `Link` header instead — the GitHub shape. That is a different pagination model, not a
+     * different spelling of one, which is precisely why it belongs in the fixture: a tool that
+     * only ever saw facts in a body may be reading conventions rather than the contract.
+     */
+    envelope: {
+        /** Property holding the array. `null` means "named after the entity" — `tables`, `rows`. */
+        collection: string | null;
+        total: string;
+        hasMore: string;
+        nextCursor?: string;
+        page: string;
+        limit: string;
+    } | null;
+    /**
+     * How filter expressions are written.
+     *
+     * `equality` has no filter parameter at all: each filterable field is its own query parameter,
+     * and only equality is expressible. It is the most common shape in the wild and the one where
+     * oat can say the least — which makes it the real test of whether "I cannot express this" is
+     * reported honestly rather than silently skipped.
+     */
+    grammar: "postgrest" | "colon" | "equality";
+    /** How sort directions are written. Defaults to the dotted form when unset. */
+    sortGrammar?: "dotted" | "prefixed" | "colon" | "spaced";
+    /** How a sparse fieldset is written. Defaults to comma-separated names. */
+    selectGrammar?: "csv" | "bracketed";
+}
+/** `field.op.value` with cursor pagination and entity-named collections. */
+export declare const POSTGREST: Dialect;
+/**
+ * A deliberately unrelated spelling: `per_page`, `sort`, `fields`, `search`, a `data` envelope
+ * with `total_count`/`has_more`, no cursor at all, and `field=op:value` filters.
+ *
+ * Nothing here shares a name with the other dialect, so a check that still works is working from
+ * the document rather than from familiarity.
+ */
+export declare const CLASSIC: Dialect;
+/**
+ * Root array, `Link` header pagination, `offset`/`limit`.
+ *
+ * No envelope at all: the body is the array, there is no total, no `hasMore`, and no page number.
+ * Whether more pages exist is answered by `rel="next"` in a header. Nothing about a check should
+ * have to change for this, and where something does, the check was reading the fixture's habits.
+ */
+export declare const LINKED: Dialect;
+/**
+ * JSON:API-flavoured: `sort=-name` for descending, `fields[table]=id,name` for projection.
+ *
+ * The parameter *names* here are unremarkable — `sort`, `fields`, `page`, `filter` — which is the
+ * point. Everything oat had generalised was the name; the value grammars stayed hardcoded to one
+ * spelling. A shape that renames nothing but writes its values differently is the sharpest test
+ * of whether that generalisation was real.
+ */
+export declare const JSONAPI: Dialect;
+/**
+ * The plainest shape there is: `?status=active&page=2`, no filter expression language at all.
+ *
+ * Half of oat's query checks cannot be expressed here — there is no way to write a negation, a
+ * range, or a pattern — and that is precisely the point. Every one of them must report what it
+ * could not test and why, because a run that goes quiet against the most common API shape in the
+ * world is the single most damaging way this tool could fail.
+ */
+export declare const PLAIN: Dialect;
+export declare const DIALECTS: Record<string, Dialect>;
+/**
+ * Rewrites a filter expression from a dialect's grammar into the canonical `field.op.value` the
+ * stores parse, so the storage layer never has to know which dialect it is serving.
+ *
+ * Returns `null` when the expression is malformed, which the caller surfaces as a 400 — the same
+ * treatment the canonical grammar gets.
+ */
+export declare function toCanonicalFilter(expression: string, dialect: Dialect): string | null;
+//# sourceMappingURL=dialect.d.ts.map

package/dist/reference/dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../src/reference/dialect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,OAAO;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,sCAAsC;IACtC,MAAM,EAAE;QACP,MAAM,EAAE,MAAM,CAAA;QACd,KAAK,EAAE,MAAM,CAAA;QACb,MAAM,EAAE,MAAM,CAAA;QACd,MAAM,EAAE,MAAM,CAAA;QACd,KAAK,EAAE,MAAM,CAAA;QACb,mFAAmF;QACnF,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,2EAA2E;QAC3E,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;IACD;;;;;;;OAOG;IACH,QAAQ,EAAE;QACT,4FAA4F;QAC5F,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;QACzB,KAAK,EAAE,MAAM,CAAA;QACb,OAAO,EAAE,MAAM,CAAA;QACf,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;KACb,GAAG,IAAI,CAAA;IACR;;;;;;;OAOG;IACH,OAAO,EAAE,WAAW,GAAG,OAAO,GAAG,UAAU,CAAA;IAC3C,+EAA+E;IAC/E,WAAW,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;IACxD,2EAA2E;IAC3E,aAAa,CAAC,EAAE,KAAK,GAAG,WAAW,CAAA;CACnC;AAED,4EAA4E;AAC5E,eAAO,MAAM,SAAS,EAAE,OAoBvB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,OAkBrB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,OAYpB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,EAAE,OAoBrB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE,OAqBnB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAM5C,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAkBrF"}

package/dist/reference/dialect.js

@@ -0,0 +1,174 @@
+/**
+ * The conventions a reference backend speaks.
+ *
+ * Everything oat had quietly hardcoded — what the page-size parameter is called, where the total
+ * lives in the envelope, how a filter expression is spelled — varies wildly between real APIs
+ * and not at all between two instances of the same fixture. A single-dialect fixture therefore
+ * proves that the checks work on *one* shape, which is a much weaker claim than it appears.
+ *
+ * Two dialects, differing in every name and in the filter grammar, turn that into a real test:
+ * the defects and the checks are identical, so anything that passes on one and fails on the
+ * other was reading a convention rather than the contract.
+ */
+/** `field.op.value` with cursor pagination and entity-named collections. */
+export const POSTGREST = {
+    envelope: {
+        collection: null,
+        hasMore: "hasMore",
+        limit: "limit",
+        nextCursor: "nextCursor",
+        page: "page",
+        total: "count",
+    },
+    grammar: "postgrest",
+    name: "postgrest",
+    params: {
+        cursor: "cursor",
+        filter: "filter",
+        limit: "limit",
+        order: "order",
+        page: "page",
+        search: "q",
+        select: "select",
+    },
+};
+/**
+ * A deliberately unrelated spelling: `per_page`, `sort`, `fields`, `search`, a `data` envelope
+ * with `total_count`/`has_more`, no cursor at all, and `field=op:value` filters.
+ *
+ * Nothing here shares a name with the other dialect, so a check that still works is working from
+ * the document rather than from familiarity.
+ */
+export const CLASSIC = {
+    envelope: {
+        collection: "data",
+        hasMore: "has_more",
+        limit: "per_page",
+        page: "page",
+        total: "total_count",
+    },
+    grammar: "colon",
+    name: "classic",
+    params: {
+        filter: "filter",
+        limit: "per_page",
+        order: "sort",
+        page: "page",
+        search: "search",
+        select: "fields",
+    },
+};
+/**
+ * Root array, `Link` header pagination, `offset`/`limit`.
+ *
+ * No envelope at all: the body is the array, there is no total, no `hasMore`, and no page number.
+ * Whether more pages exist is answered by `rel="next"` in a header. Nothing about a check should
+ * have to change for this, and where something does, the check was reading the fixture's habits.
+ */
+export const LINKED = {
+    envelope: null,
+    grammar: "postgrest",
+    name: "linked",
+    params: {
+        filter: "filter",
+        limit: "limit",
+        offset: "offset",
+        order: "order",
+        search: "q",
+        select: "fields",
+    },
+};
+/**
+ * JSON:API-flavoured: `sort=-name` for descending, `fields[table]=id,name` for projection.
+ *
+ * The parameter *names* here are unremarkable — `sort`, `fields`, `page`, `filter` — which is the
+ * point. Everything oat had generalised was the name; the value grammars stayed hardcoded to one
+ * spelling. A shape that renames nothing but writes its values differently is the sharpest test
+ * of whether that generalisation was real.
+ */
+export const JSONAPI = {
+    envelope: {
+        collection: "data",
+        hasMore: "has_more",
+        limit: "size",
+        page: "number",
+        total: "total",
+    },
+    grammar: "postgrest",
+    name: "jsonapi",
+    params: {
+        filter: "filter",
+        limit: "size",
+        order: "sort",
+        page: "page",
+        search: "q",
+        select: "fields",
+    },
+    selectGrammar: "bracketed",
+    sortGrammar: "prefixed",
+};
+/**
+ * The plainest shape there is: `?status=active&page=2`, no filter expression language at all.
+ *
+ * Half of oat's query checks cannot be expressed here — there is no way to write a negation, a
+ * range, or a pattern — and that is precisely the point. Every one of them must report what it
+ * could not test and why, because a run that goes quiet against the most common API shape in the
+ * world is the single most damaging way this tool could fail.
+ */
+export const PLAIN = {
+    envelope: {
+        collection: "items",
+        hasMore: "has_more",
+        limit: "limit",
+        page: "page",
+        total: "total",
+    },
+    grammar: "equality",
+    name: "plain",
+    params: {
+        /* Declared for completeness; the equality grammar never sends it, and the fixture never
+         * reads it. A parameter a backend accepts and ignores is itself a defect oat reports. */
+        filter: "filter",
+        limit: "limit",
+        order: "sort",
+        page: "page",
+        search: "q",
+        select: "fields",
+    },
+    sortGrammar: "colon",
+};
+export const DIALECTS = {
+    jsonapi: JSONAPI,
+    plain: PLAIN,
+    classic: CLASSIC,
+    linked: LINKED,
+    postgrest: POSTGREST,
+};
+/**
+ * Rewrites a filter expression from a dialect's grammar into the canonical `field.op.value` the
+ * stores parse, so the storage layer never has to know which dialect it is serving.
+ *
+ * Returns `null` when the expression is malformed, which the caller surfaces as a 400 — the same
+ * treatment the canonical grammar gets.
+ */
+export function toCanonicalFilter(expression, dialect) {
+    /* Already canonical: the postgrest grammar *is* the canonical form, and the equality grammar
+     * has no expression of its own — the per-field parameters were assembled into canonical terms
+     * before reaching here. Re-parsing that would reject a well-formed expression. */
+    if (dialect.grammar === "postgrest" || dialect.grammar === "equality")
+        return expression;
+    /* `status=eq:active`, joined by commas. No grouping: the point of a second dialect is
+     * different spelling, not a second expression language to maintain. */
+    const terms = expression.split(",").map((term) => term.trim()).filter(Boolean);
+    if (terms.length === 0)
+        return null;
+    const canonical = [];
+    for (const term of terms) {
+        const match = /^([^=]+)=([a-z]+):(.*)$/s.exec(term);
+        if (match?.[1] === undefined || match[2] === undefined || match[3] === undefined)
+            return null;
+        canonical.push(`${match[1]}.${match[2]}.${match[3]}`);
+    }
+    return canonical.length === 1 ? canonical[0] : `and(${canonical.join(",")})`;
+}
+//# sourceMappingURL=dialect.js.map

package/dist/reference/dialect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.js","sourceRoot":"","sources":["../../src/reference/dialect.ts"],"names":[],"mappings":"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"}

package/dist/reference/http.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The reference backend's HTTP layer — one implementation, any store.
+ *
+ * Routing, auth, tenancy, validation and the defect behaviours that live above storage are
+ * written once here. Each engine supplies only a `Store`, so a defect is defined in one place
+ * and exercised identically on every backend; when two engines then disagree about what that
+ * defect *does*, the disagreement is real rather than an artefact of two implementations
+ * drifting apart.
+ *
+ * Backends: `createMemoryServer` (no dependencies), `createSqliteServer` (`node:sqlite`),
+ * `createD1Server` (Cloudflare D1 over HTTP),
+ * `createPostgresServer` (a reachable server). Every store is imported lazily — a static import
+ * would load one engine's driver for all of them, and an optional runtime such as `node:sqlite`
+ * would take down paths that never touch it.
+ *
+ * This is a test fixture. It is excluded from the published package; oat itself never talks to
+ * a database.
+ */
+import { type Server } from "node:http";
+import { type DefectSet } from "./defects.ts";
+import { type Store } from "./store-api.ts";
+interface Principal {
+    key: string;
+    token: string;
+    projectId: string;
+    /** Higher can do everything a lower rank can. Viewer 0, member 1, owner 2. */
+    rank: number;
+}
+export interface ReferenceServer {
+    server: Server;
+    url: string;
+    defects: DefectSet;
+    close: () => Promise<void>;
+    principals: Principal[];
+}
+/**
+ * One server, any store. Defining a defect once and exercising it on every engine is what makes
+ * a disagreement between engines meaningful rather than an artefact of two implementations.
+ */
+export declare function createReferenceServer(options: {
+    defects?: string[];
+    untagged?: boolean;
+    dialect?: string;
+}, createStore: (defects: DefectSet) => Promise<Store>): Promise<ReferenceServer>;
+/** In-memory reference server — no dependencies, no flags, nothing to have running. */
+export declare function createMemoryServer(options?: {
+    defects?: string[];
+    untagged?: boolean;
+    dialect?: string;
+}): Promise<ReferenceServer>;
+/** SQLite-backed reference server, in-process via `node:sqlite`. */
+export declare function createSqliteServer(options?: {
+    defects?: string[];
+    untagged?: boolean;
+    dialect?: string;
+}): Promise<ReferenceServer>;
+/**
+ * Cloudflare D1 reference server — the same SQL over the network, against someone else's build.
+ *
+ * Credentials come from the environment rather than config so a token never reaches a file that
+ * could be committed. Tables are prefixed per run and dropped on close, because D1 persists: two
+ * runs sharing one database would otherwise contaminate each other's results.
+ */
+export declare function createD1Server(options?: {
+    defects?: string[];
+    untagged?: boolean;
+    dialect?: string;
+    accountId?: string;
+    databaseId?: string;
+    apiToken?: string;
+}): Promise<ReferenceServer>;
+/** Postgres-backed reference server. Imported lazily so the driver is only loaded when used. */
+export declare function createPostgresServer(options?: {
+    defects?: string[];
+    untagged?: boolean;
+    dialect?: string;
+}): Promise<ReferenceServer>;
+export {};
+//# sourceMappingURL=http.d.ts.map

package/dist/reference/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/reference/http.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAsC,KAAK,MAAM,EAAuB,MAAM,WAAW,CAAA;AAEhG,OAAO,EAAwB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAInE,OAAO,EAAsB,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE/D,UAAU,SAAS;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAA;CACZ;AAoJD,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,UAAU,EAAE,SAAS,EAAE,CAAA;CACvB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAC1C,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,EAIrE,WAAW,EAAE,CAAC,OAAO,EAAE,SAAS,KAAK,OAAO,CAAC,KAAK,CAAC,GACjD,OAAO,CAAC,eAAe,CAAC,CAwlB1B;AAmKD,uFAAuF;AACvF,wBAAsB,kBAAkB,CACvC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACxE,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED,oEAAoE;AACpE,wBAAsB,kBAAkB,CACvC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACxE,OAAO,CAAC,eAAe,CAAC,CAM1B;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CACnC,OAAO,GAAE;IACR,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACZ,GACJ,OAAO,CAAC,eAAe,CAAC,CA2B1B;AAED,gGAAgG;AAChG,wBAAsB,oBAAoB,CACzC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACxE,OAAO,CAAC,eAAe,CAAC,CAG1B"}