@sasjs/api 0.0.0-stage → 0.2.0

package/build/cjs/routes/index.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRoute = exports.routeById = exports.ROUTES = void 0;
+/**
+ * The route table, and the one matcher both hosts dispatch with.
+ *
+ * `GENERATED_ROUTES` is the OpenAPI document, `OVERLAY` is the part a document
+ * cannot carry, and this file is where they meet. Importing it validates the
+ * join as a side effect: an overlay entry naming an operation the document does
+ * not have is a stale entry, and it throws here rather than being silently
+ * ignored - the failure mode that lets a "documented" behaviour rot.
+ */
+const generated_js_1 = require("./generated.js");
+const overlay_js_1 = require("./overlay.js");
+const merge = (generated) => {
+    const overlay = overlay_js_1.OVERLAY[generated.id] || {};
+    const documented = new Map(generated.responses.map((r) => [r.status, r.description]));
+    // The document states the statuses and the overlay only annotates the ones a
+    // client keys a body on. Naming a status the document does not state is a
+    // build failure: the alternative - listing it anyway - advertises a status
+    // nothing can observe without the parity test failing, which is a documented
+    // wish rather than a contract. A host that genuinely answers a status the
+    // document omits needs the document corrected in sasjs/server.
+    for (const status of Object.keys(overlay.responses || {}).map(Number)) {
+        if (!documented.has(status)) {
+            throw new Error(`src/routes/overlay.ts annotates status ${status} for ${generated.id}, which the OpenAPI document does not state. Correct the document in sasjs/server and re-vendor spec/swagger.yaml, or drop the annotation.`);
+        }
+    }
+    const responses = [...documented.keys()]
+        .sort((a, b) => a - b)
+        .map((status) => {
+        const body = overlay.responses ? overlay.responses[status] : undefined;
+        return {
+            status,
+            description: documented.get(status) || '',
+            ...(body === undefined ? {} : { body })
+        };
+    });
+    return {
+        ...generated,
+        responses,
+        capabilities: overlay.capabilities || overlay_js_1.TAG_CAPABILITIES[generated.tag] || [],
+        implemented: overlay.implemented === true
+    };
+};
+exports.ROUTES = generated_js_1.GENERATED_ROUTES.map(merge);
+const known = new Set(exports.ROUTES.map((route) => route.id));
+for (const id of Object.keys(overlay_js_1.OVERLAY))
+    if (!known.has(id))
+        throw new Error(`src/routes/overlay.ts names an operation the OpenAPI document does not have: ${id}. Remove the entry or refresh spec/swagger.yaml.`);
+const byId = new Map(exports.ROUTES.map((route) => [route.id, route]));
+/** The route with this `METHOD /path` identity, if the document has one. */
+const routeById = (id) => byId.get(id);
+exports.routeById = routeById;
+const escape = (segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Compiles a documented path into a matcher. The table is static, so this runs
+ * once at import; `findRoute` then tests exact paths first (most of the API is
+ * static) and only falls through to the templates for `{uid}`-style paths.
+ */
+const compiled = exports.ROUTES.filter((route) => route.path.includes('{')).map((route) => {
+    const keys = [];
+    const pattern = route.path
+        .split('/')
+        .map((segment) => {
+        if (segment.startsWith('{') && segment.endsWith('}')) {
+            keys.push(segment.slice(1, -1));
+            return '([^/]+)';
+        }
+        return escape(segment);
+    })
+        .join('/');
+    return { route, keys, regex: new RegExp('^' + pattern + '/?$') };
+});
+const exact = new Map();
+for (const route of exports.ROUTES)
+    if (!route.path.includes('{'))
+        exact.set(route.method + ' ' + route.path, route);
+/**
+ * The route a request names, or undefined when the API has no such operation.
+ *
+ * A host that gets undefined answers 404 "not part of the API"; a host that gets
+ * a route it cannot serve answers 501 naming the capability. Keeping those two
+ * apart is the difference between a client's bug and a host's limit.
+ */
+const findRoute = (method, path) => {
+    const verb = method.toUpperCase();
+    const clean = path.split('?')[0].replace(/\/+$/, '') || '/';
+    const hit = exact.get(verb + ' ' + clean);
+    if (hit)
+        return { route: hit, params: {} };
+    for (const candidate of compiled) {
+        if (candidate.route.method !== verb)
+            continue;
+        const match = candidate.regex.exec(clean);
+        if (!match)
+            continue;
+        const params = {};
+        candidate.keys.forEach((key, index) => {
+            try {
+                params[key] = decodeURIComponent(match[index + 1]);
+            }
+            catch {
+                params[key] = match[index + 1];
+            }
+        });
+        return { route: candidate.route, params };
+    }
+    return undefined;
+};
+exports.findRoute = findRoute;

package/build/cjs/routes/overlay.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METHODS = exports.OVERLAY = exports.TAG_CAPABILITIES = void 0;
+/** The default capability for each tag, overridden per route where it differs. */
+exports.TAG_CAPABILITIES = {
+    Drive: ['storage'],
+    STP: ['runtime', 'storage'],
+    Code: ['runtime'],
+    Session: ['runtime'],
+    Info: [],
+    Admin: ['storage'],
+    Auth: ['identity'],
+    'Auth Config': ['identity'],
+    User: ['identity'],
+    Group: ['identity'],
+    Permission: ['identity'],
+    Client: ['identity'],
+    Web: ['identity']
+};
+const success = { status: 'success' };
+exports.OVERLAY = {
+    // the route inventory reports what the CALLER may use, so it needs an identity
+    // even though the rest of the Info tag needs nothing
+    'GET /SASjsApi/info/authorizedRoutes': { capabilities: ['identity'] },
+    'GET /SASjsApi/info/myAuthorizedRoutes': { capabilities: ['identity'] },
+    // the body is the file itself, so there is nothing to annotate
+    'GET /SASjsApi/drive/file': { implemented: true },
+    'POST /SASjsApi/drive/file': {
+        implemented: true,
+        responses: { 200: success, 409: 'File already exists.' }
+    },
+    'PATCH /SASjsApi/drive/file': {
+        implemented: true,
+        responses: { 200: success, 404: `File doesn't exist.` }
+    },
+    'DELETE /SASjsApi/drive/file': {
+        implemented: true,
+        responses: { 200: success, 404: `File doesn't exist.` }
+    },
+    'GET /SASjsApi/drive/folder': {
+        implemented: true,
+        responses: { 200: { files: [], folders: [] } }
+    },
+    'POST /SASjsApi/drive/folder': {
+        implemented: true,
+        responses: { 200: success, 409: 'Folder already exists.' }
+    },
+    'DELETE /SASjsApi/drive/folder': {
+        implemented: true,
+        responses: { 200: success, 404: `Folder doesn't exist.` }
+    },
+    'POST /SASjsApi/drive/rename': {
+        implemented: true,
+        responses: {
+            200: success,
+            409: 'File with new name already exists.',
+            404: 'No file/folder found for provided path.'
+        }
+    },
+    'GET /SASjsApi/drive/filetree': {
+        implemented: true,
+        responses: { 200: { status: 'success', tree: {} } }
+    },
+    // The two deploy routes write a whole tree in one request. They are the only
+    // ones where a caller can exhaust the host's storage, so they carry a cap -
+    // see the plan in sasjs/cli#1550 - and they are not implemented yet.
+    'POST /SASjsApi/drive/deploy': {
+        implemented: false
+    },
+    'POST /SASjsApi/drive/deploy/upload': {
+        implemented: false
+    }
+};
+/** Every method the table may state, in the order a diff reads best. */
+exports.METHODS = ['GET', 'POST', 'PATCH', 'DELETE', 'PUT'];

package/build/cjs/types.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * The vocabulary the two hosts share.
+ *
+ * Nothing here imports a runtime: the package is consumed by an Express server
+ * in node and by a service worker in a browser, so the types are all this file
+ * may contain. That is also why the build compiles `src` with `types: []` - an
+ * accidental `Buffer` or `process` reference fails the build rather than the
+ * worker at run time.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isApiError = exports.ApiError = void 0;
+/**
+ * A refusal the API answers with: the status a client keys on, and the message
+ * it prints. Both hosts throw this and both render it the same way, so the
+ * corpus can assert on the pair.
+ */
+class ApiError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        /** Told apart by marker rather than `instanceof` - see `isApiError`. */
+        this.apiError = true;
+        this.name = 'ApiError';
+    }
+}
+exports.ApiError = ApiError;
+/**
+ * `instanceof` survives here (the package targets ES2020, not ES5), but a
+ * consumer that downlevels it - the CLI does - loses the prototype chain, so the
+ * marker is what the checks use. Asserting both in a spec is what keeps that
+ * honest.
+ */
+const isApiError = (value) => !!value && value.apiError === true;
+exports.isApiError = isApiError;

package/build/esm/corpus/drive.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The conformance corpus: what the API does, as data.
+ *
+ * Each case names an operation, the request a client would make, and the answer
+ * a client expects - the status, the body, or the file's contents. The same
+ * cases run against a live sasjs/server and against the browser build, which is
+ * the only way "the same API" becomes something a test can hold; two hand-
+ * written suites is how the header seed and the webout block drifted.
+ *
+ * The statuses and the wording are the implementation's (sasjs/server's
+ * controllers), not the published document's, and `src/routes/overlay.ts`
+ * records each place the two disagree.
+ */
+import type { ApiRequest } from '../host/dispatch.js';
+export interface CorpusCase {
+    /** Stable name, used as the test's title. */
+    id: string;
+    /** The operation, `METHOD /path` as the route table states it. */
+    route: string;
+    description: string;
+    /** Files the case starts from. */
+    seed?: Record<string, string | Uint8Array>;
+    request: ApiRequest;
+    expect: {
+        status: number;
+        body?: unknown;
+        contents?: string | Uint8Array;
+        /** The refusal's message, where the case expects one. */
+        error?: string;
+    };
+}
+export declare const DRIVE_CORPUS: CorpusCase[];
+//# sourceMappingURL=drive.d.ts.map

package/build/esm/corpus/drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../src/corpus/drive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAErD,MAAM,WAAW,UAAU;IACzB,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAA;IACV,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,kCAAkC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAA;IAC1C,OAAO,EAAE,UAAU,CAAA;IACnB,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,CAAA;QACd,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;QAC9B,yDAAyD;QACzD,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAWD,eAAO,MAAM,YAAY,EAAE,UAAU,EAyRpC,CAAA"}

package/build/esm/corpus/drive.js

@@ -0,0 +1,285 @@
+const success = { status: 'success' };
+/**
+ * Bytes without an encoding API: the package builds with `lib: ES2020` and no
+ * ambient types, so a `TextEncoder` reference would compile here and fail in a
+ * host that does not have one. An explicit byte array is both.
+ */
+const bytes = (...values) => Uint8Array.from(values);
+export const DRIVE_CORPUS = [
+    {
+        id: 'create-file',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'creates a file the drive did not have',
+        request: {
+            query: { _filePath: '/data/users.csv' },
+            file: { name: 'users.csv', contents: 'id,name\n1,Ann\n' }
+        },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'create-file-at-form-path',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'takes the destination from the form field when the query has none',
+        request: {
+            file: { name: 'x.csv', contents: 'x' },
+            body: { filePath: '/data/from-form.csv' }
+        },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'create-file-over-existing',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'refuses a create over a file that exists, as 409',
+        seed: { '/data/exists.csv': 'a' },
+        request: {
+            query: { _filePath: '/data/exists.csv' },
+            file: { name: 'x', contents: 'b' }
+        },
+        expect: { status: 409, error: 'File already exists.' }
+    },
+    {
+        id: 'create-file-blocked-extension',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'refuses a refused extension before touching the drive',
+        request: {
+            query: { _filePath: '/data/run.sh' },
+            file: { name: 'run.sh', contents: 'x' }
+        },
+        expect: { status: 400, error: 'Invalid file extension' }
+    },
+    {
+        id: 'create-file-outside-drive',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'refuses a path that climbs out of the drive',
+        request: {
+            query: { _filePath: '/../escape.csv' },
+            file: { name: 'x', contents: 'x' }
+        },
+        expect: { status: 400, error: "Can't put file outside drive." }
+    },
+    {
+        id: 'create-file-without-payload',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'answers for a missing file with the server wording',
+        request: { query: { _filePath: '/data/x.csv' } },
+        expect: { status: 400, error: '"file" is not present.' }
+    },
+    {
+        id: 'create-file-without-destination',
+        route: 'POST /SASjsApi/drive/file',
+        description: 'answers for a missing destination with the validation wording',
+        request: { file: { name: 'x', contents: 'x' } },
+        expect: { status: 400, error: '"_filePath" is required' }
+    },
+    {
+        id: 'replace-file',
+        route: 'PATCH /SASjsApi/drive/file',
+        description: 'replaces the contents of a file that exists',
+        seed: { '/data/keep.csv': 'old' },
+        request: {
+            query: { _filePath: '/data/keep.csv' },
+            file: { name: 'keep.csv', contents: 'new' }
+        },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'replace-file-missing',
+        route: 'PATCH /SASjsApi/drive/file',
+        description: 'refuses a replace of a file that is not there, as 404',
+        request: {
+            query: { _filePath: '/data/missing.csv' },
+            file: { name: 'x', contents: 'x' }
+        },
+        expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+        id: 'replace-file-outside-drive',
+        route: 'PATCH /SASjsApi/drive/file',
+        description: 'refuses a replace of a path that climbs out of the drive',
+        request: {
+            query: { _filePath: '/../escape.csv' },
+            file: { name: 'x', contents: 'x' }
+        },
+        expect: { status: 400, error: "Can't modify file outside drive." }
+    },
+    {
+        id: 'read-file',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'answers with the file contents',
+        seed: { '/data/keep.csv': 'a,b\n1,2\n' },
+        request: { query: { _filePath: '/data/keep.csv' } },
+        expect: { status: 200, contents: 'a,b\n1,2\n' }
+    },
+    {
+        id: 'read-file-missing',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'refuses a read of a file that is not there',
+        request: { query: { _filePath: '/data/missing.csv' } },
+        expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+        id: 'read-file-outside-drive',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'refuses a read of a path that climbs out of the drive',
+        request: { query: { _filePath: '/../escape.csv' } },
+        expect: { status: 400, error: "Can't get file outside drive." }
+    },
+    {
+        id: 'delete-file',
+        route: 'DELETE /SASjsApi/drive/file',
+        description: 'deletes a file that exists',
+        seed: { '/data/keep.csv': 'a' },
+        request: { query: { _filePath: '/data/keep.csv' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'delete-file-missing',
+        route: 'DELETE /SASjsApi/drive/file',
+        description: 'refuses a delete of a file that is not there',
+        request: { query: { _filePath: '/data/missing.csv' } },
+        expect: { status: 404, error: `File doesn't exist.` }
+    },
+    {
+        id: 'delete-file-outside-drive',
+        route: 'DELETE /SASjsApi/drive/file',
+        description: 'refuses a delete of a path that climbs out of the drive',
+        request: { query: { _filePath: '/../escape.csv' } },
+        expect: { status: 400, error: "Can't delete file outside drive." }
+    },
+    {
+        id: 'list-folder',
+        route: 'GET /SASjsApi/drive/folder',
+        description: 'lists the files and folders of a folder',
+        seed: { '/data/a.csv': 'a', '/data/reports/b.csv': 'b' },
+        request: { query: { _folderPath: '/data' } },
+        expect: { status: 200, body: { files: ['a.csv'], folders: ['reports'] } }
+    },
+    {
+        id: 'list-folder-missing',
+        route: 'GET /SASjsApi/drive/folder',
+        description: 'refuses a listing of a folder that is not there',
+        request: { query: { _folderPath: '/nope' } },
+        expect: { status: 404, error: `Folder doesn't exist.` }
+    },
+    {
+        id: 'list-folder-outside-drive',
+        route: 'GET /SASjsApi/drive/folder',
+        description: 'refuses a listing of a path that climbs out of the drive',
+        request: { query: { _folderPath: '/../escape' } },
+        expect: { status: 400, error: "Can't get folder outside drive." }
+    },
+    {
+        id: 'delete-folder-without-path',
+        route: 'DELETE /SASjsApi/drive/folder',
+        description: 'answers for a missing folder path, because the table marks it required',
+        request: {},
+        expect: { status: 400, error: '"_folderPath" is required' }
+    },
+    {
+        id: 'create-folder-without-path',
+        route: 'POST /SASjsApi/drive/folder',
+        description: 'answers for a missing folder path in the body',
+        request: { body: {} },
+        expect: { status: 400, error: '"folderPath" is required' }
+    },
+    {
+        id: 'create-folder',
+        route: 'POST /SASjsApi/drive/folder',
+        description: 'creates a folder',
+        request: { body: { folderPath: '/data/reports' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'create-folder-existing',
+        route: 'POST /SASjsApi/drive/folder',
+        description: 'refuses a folder that already exists, as 409',
+        seed: { '/data/reports/a.csv': 'a' },
+        request: { body: { folderPath: '/data/reports' } },
+        expect: { status: 409, error: 'Folder already exists.' }
+    },
+    {
+        id: 'delete-folder',
+        route: 'DELETE /SASjsApi/drive/folder',
+        description: 'deletes a folder with everything under it',
+        seed: { '/data/reports/a.csv': 'a', '/data/reports/nested/b.csv': 'b' },
+        request: { query: { _folderPath: '/data/reports' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'delete-folder-missing',
+        route: 'DELETE /SASjsApi/drive/folder',
+        description: 'refuses a delete of a folder that is not there',
+        request: { query: { _folderPath: '/nope' } },
+        expect: { status: 404, error: `Folder doesn't exist.` }
+    },
+    {
+        id: 'rename-file',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'moves a file to a new path',
+        seed: { '/data/old.csv': 'r' },
+        request: { body: { oldPath: '/data/old.csv', newPath: '/data/new.csv' } },
+        expect: { status: 200, body: success }
+    },
+    {
+        id: 'rename-onto-existing',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'refuses a move onto something that exists',
+        seed: { '/data/a.csv': 'a', '/data/b.csv': 'b' },
+        request: { body: { oldPath: '/data/a.csv', newPath: '/data/b.csv' } },
+        expect: { status: 409, error: 'File with new name already exists.' }
+    },
+    {
+        id: 'rename-missing',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'refuses a move of something that is not there',
+        request: { body: { oldPath: '/data/nope.csv', newPath: '/data/x.csv' } },
+        expect: { status: 404, error: 'No file/folder found for provided path.' }
+    },
+    {
+        id: 'rename-folder-into-itself',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'refuses a folder moved inside itself, which the server loses at the filesystem',
+        seed: { '/data/reports/a.csv': 'a' },
+        request: {
+            body: { oldPath: '/data/reports', newPath: '/data/reports/nested' }
+        },
+        expect: {
+            status: 400,
+            error: "New path can't be inside the folder being moved."
+        }
+    },
+    {
+        id: 'tree',
+        route: 'GET /SASjsApi/drive/filetree',
+        description: 'answers with the drive tree',
+        seed: { '/data/a.csv': 'a' },
+        request: { query: { _folderPath: '/data' } },
+        expect: {
+            status: 200,
+            body: {
+                status: 'success',
+                tree: {
+                    name: 'data',
+                    relativePath: '/data',
+                    isFolder: true,
+                    children: [
+                        {
+                            name: 'a.csv',
+                            relativePath: '/data/a.csv',
+                            isFolder: false,
+                            children: []
+                        }
+                    ]
+                }
+            }
+        }
+    },
+    {
+        id: 'bytes-round-trip',
+        route: 'GET /SASjsApi/drive/file',
+        description: 'keeps a byte file as bytes',
+        seed: { '/data/pack.zip': bytes(80, 75, 3, 4) },
+        request: { query: { _filePath: '/data/pack.zip' } },
+        expect: { status: 200, contents: bytes(80, 75, 3, 4) }
+    }
+];

package/build/esm/corpus/runner.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Runs a corpus case against a drive the case seeds itself.
+ *
+ * The runner exists so the corpus is data rather than a spec file: a host proves
+ * its conformance by supplying something that answers `dispatch`, and the
+ * assertions live in one place. Today that is this package's services over a
+ * `MemoryDriveStore`; a live server and the browser build plug in through their
+ * own transports and the same cases run there.
+ */
+import type { CorpusCase } from './drive.js';
+import type { Services } from '../host/dispatch.js';
+export interface CaseResult {
+    status: number;
+    body?: unknown;
+    contents?: string | Uint8Array;
+    /** The refusal's message, when the case was refused. */
+    error?: string;
+}
+/** Services over a fresh store, seeded with the case's files. */
+export declare const servicesFor: (testCase: CorpusCase) => Services;
+/**
+ * Runs a corpus case against the drive the case seeds itself, or against
+ * services a caller supplies - that is how a host (or a failing store) is put
+ * behind the same cases.
+ */
+export declare const runCase: (testCase: CorpusCase, services?: Services) => Promise<CaseResult>;
+//# sourceMappingURL=runner.d.ts.map

package/build/esm/corpus/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/corpus/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAKnD,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;IAC9B,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,iEAAiE;AACjE,eAAO,MAAM,WAAW,GAAI,UAAU,UAAU,KAAG,QAEjD,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAClB,UAAU,UAAU,EACpB,WAAU,QAAgC,KACzC,OAAO,CAAC,UAAU,CAcpB,CAAA"}

package/build/esm/corpus/runner.js

@@ -0,0 +1,30 @@
+import { dispatch } from '../host/dispatch.js';
+import { createDriveService } from '../drive/service.js';
+import { MemoryDriveStore } from '../drive/memory-store.js';
+import { isApiError } from '../types.js';
+/** Services over a fresh store, seeded with the case's files. */
+export const servicesFor = (testCase) => ({
+    drive: createDriveService(new MemoryDriveStore(testCase.seed || {}))
+});
+/**
+ * Runs a corpus case against the drive the case seeds itself, or against
+ * services a caller supplies - that is how a host (or a failing store) is put
+ * behind the same cases.
+ */
+export const runCase = async (testCase, services = servicesFor(testCase)) => {
+    try {
+        const response = await dispatch(services, testCase.route, testCase.request);
+        return {
+            status: response.status,
+            body: response.body,
+            contents: response.contents
+        };
+    }
+    catch (error) {
+        // only a refusal the API decided on becomes a status; anything else is a
+        // broken host, and reporting it as a 500 would hide it from the suite
+        if (isApiError(error))
+            return { status: error.status, error: error.message };
+        throw error;
+    }
+};

package/build/esm/drive/memory-store.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A `DriveStore` over two Maps, for tests and for hosts that have no filesystem.
+ *
+ * It is deliberately not clever: text is kept as a string, bytes as a copy of
+ * the `Uint8Array`, and folders are implied by the paths that exist plus the
+ * ones `mkdirp` recorded. That is exactly the model the browser build needs, so
+ * a host can use this class as its store rather than writing another one - the
+ * browser build already persists the whole drive as a map of path to string.
+ */
+import type { DriveStore } from '../types.js';
+type Entry = string | Uint8Array;
+export declare class MemoryDriveStore implements DriveStore {
+    private files;
+    private folders;
+    constructor(seed?: Record<string, Entry>);
+    /** Everything on the drive, for a snapshot or an assertion. */
+    dump(): Record<string, Entry>;
+    private putSync;
+    private mkdirpSync;
+    private children;
+    read(path: string): Promise<Entry>;
+    write(path: string, contents: Entry): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<{
+        directory: boolean;
+        size: number;
+    }>;
+    list(path: string): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+    mkdirp(path: string): Promise<void>;
+    remove(path: string): Promise<void>;
+    move(from: string, to: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=memory-store.d.ts.map

package/build/esm/drive/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../../src/drive/memory-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAI7C,KAAK,KAAK,GAAG,MAAM,GAAG,UAAU,CAAA;AAEhC,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,OAAO,CAAyB;gBAE5B,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM;IAM5C,+DAA+D;IAC/D,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAM7B,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,QAAQ;IAiBV,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAMlC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAInD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAItC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAWjE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAInE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYnC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA8BpD"}