@sasjs/api 0.5.0 → 0.6.1

package/README.md

@@ -67,7 +67,7 @@ The bundle is deliberately a classic-worker IIFE: a service worker registered by
 Both hosts answer with the same shapes:
 
 - a successful write is `{ status: 'success' }`;
-- a refusal is an `ApiError` carrying `status` and `message`, which a host renders as its own transport requires (`res.status(code).send(...)` on the server, a `Response` in the worker);
+- a refusal is an `ApiError` carrying `status`, `message` and, where the route answers an envelope rather than text, the `body` to send instead of the bare message - which a host renders as its own transport requires (`res.status(code).send(...)` on the server, a `Response` in the worker);
 - an operation this package has no handler for is `501`, naming the operation and the reason it is not implemented here - not a `404` that looks like a typo in the caller;
 - an operation the API does not have is `404`.
 
@@ -94,6 +94,7 @@ Three of the sign-in flow's defences are the host's, because the package has no
 - **Re-resolve the caller on every request.** A host with its own session passes the subject in (`session`, `authorize`), so the service re-reads the account behind it and refuses a deactivated one; a host that caches the subject it resolved at sign-in defeats that check. `logout` is the exception and does not refuse: dropping a credential is not access, and refusing would leave the pair in the store.
 - **Lock the account out after repeated failures.** `POST /SASLogon/login` answers `401 Username is not found.` for an unknown username and `401 Invalid Password.` for a wrong one, because that is what the server's own form tells a user - which also means the route cannot tell a caller to stop guessing on its own. The defence is the host's limiter, answering `429` with `Retry-After` in seconds; without it the route is a way to enumerate usernames and account state.
 - **Answer a session-store or identity-provider failure with `500`.** Those are the host's own dependencies, and the overlay marks the statuses as `hostResponses`.
+- **Admit `DEPLOY_PAYLOAD_BYTES` on the deploy route, and only there.** The deploy cap is stated in decoded bytes and its tree travels as JSON in which file contents are base64, so a tree at the cap reaches the parser at up to ~134 MB; a smaller body limit refuses first, with its own shape, and the cap is never consulted. Every other route keeps the smaller limit, because a body is buffered before authentication.
 
 ## Development
 

package/build/browser.js

@@ -1,4 +1,4 @@
-/* @sasjs/api 0.5.0 - the SASjs Server API, for a service worker. https://github.com/sasjs/api */
+/* @sasjs/api 0.6.1 - the SASjs Server API, for a service worker. https://github.com/sasjs/api */
 "use strict";
 var SASjsApi = (() => {
   var __defProp = Object.defineProperty;
@@ -24,6 +24,9 @@ var SASjsApi = (() => {
   __export(index_exports, {
     ApiError: () => ApiError,
     DEFAULT_IDENTITY: () => DEFAULT_IDENTITY,
+    DEPLOY_LIMITS: () => DEPLOY_LIMITS,
+    DEPLOY_PAYLOAD_BYTES: () => DEPLOY_PAYLOAD_BYTES,
+    DEPLOY_SUCCESS: () => DEPLOY_SUCCESS,
     DRIVE_CORPUS: () => DRIVE_CORPUS,
     HANDLED_ROUTES: () => HANDLED_ROUTES,
     IDENTITY_CORPUS: () => IDENTITY_CORPUS,
@@ -34,14 +37,19 @@ var SASjsApi = (() => {
     ROUTES: () => ROUTES,
     TAG_CAPABILITIES: () => TAG_CAPABILITIES,
     basename: () => basename,
+    checkDeployTree: () => checkDeployTree,
     createDriveService: () => createDriveService,
     createIdentityService: () => createIdentityService,
+    decodeBase64: () => decodeBase64,
+    deployTree: () => deployTree,
     dirname: () => dirname,
     dispatch: () => dispatch,
     findRoute: () => findRoute,
     hasBlockedExtension: () => hasBlockedExtension,
     isApiError: () => isApiError,
+    isDeployTree: () => isDeployTree,
     isRoot: () => isRoot,
+    measureDeployTree: () => measureDeployTree,
     normaliseDrivePath: () => normaliseDrivePath,
     parseIdentity: () => parseIdentity,
     routeById: () => routeById,
@@ -51,9 +59,10 @@ var SASjsApi = (() => {
 
   // src/types.ts
   var ApiError = class extends Error {
-    constructor(status, message) {
+    constructor(status, message, body) {
       super(message);
       this.status = status;
+      this.body = body;
       /** Told apart by marker rather than `instanceof` - see `isApiError`. */
       this.apiError = true;
       this.name = "ApiError";
@@ -91,6 +100,182 @@ var SASjsApi = (() => {
     return { path };
   };
 
+  // src/drive/deploy.ts
+  var DEPLOY_LIMITS = {
+    entries: 1e4,
+    totalBytes: 100 * 1024 * 1024,
+    fileBytes: 20 * 1024 * 1024
+  };
+  var DEPLOY_PAYLOAD_BYTES = 140 * 1024 * 1024;
+  var DEPLOY_SUCCESS = {
+    status: "success",
+    message: "Files deployed successfully to @sasjs/server."
+  };
+  var MAX_DEPTH = 32;
+  var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var base64Body = (value) => value.replace(/[^A-Za-z0-9+/]/g, "");
+  var base64Length = (value) => Math.floor(base64Body(value).length * 3 / 4);
+  var decodeBase64 = (value) => {
+    const body = base64Body(value);
+    const bytes2 = new Uint8Array(Math.floor(body.length * 3 / 4));
+    let buffer = 0;
+    let bits = 0;
+    let at = 0;
+    for (const char of body) {
+      buffer = buffer << 6 | BASE64_ALPHABET.indexOf(char);
+      bits += 6;
+      if (bits >= 8) {
+        bits -= 8;
+        bytes2[at++] = buffer >> bits & 255;
+      }
+    }
+    return bytes2.subarray(0, at);
+  };
+  var utf8Length = (value) => {
+    let bytes2 = 0;
+    for (let at = 0; at < value.length; at++) {
+      const code = value.charCodeAt(at);
+      if (code < 128) bytes2 += 1;
+      else if (code < 2048) bytes2 += 2;
+      else if (code >= 55296 && code <= 56319 && at + 1 < value.length) {
+        bytes2 += 4;
+        at++;
+      } else bytes2 += 3;
+    }
+    return bytes2;
+  };
+  var memberName = (member) => member.type === "service" ? `${member.name}.sas` : member.name;
+  var memberBytes = (member) => member.type === "file" ? base64Length(member.code) : utf8Length(member.code);
+  var MEGABYTE = 1024 * 1024;
+  var describeSize = (bytes2) => bytes2 < MEGABYTE ? `${bytes2} bytes` : `${Math.ceil(bytes2 / MEGABYTE * 10) / 10} MB`;
+  var describeLimit = (bytes2) => bytes2 < MEGABYTE ? `${bytes2} bytes` : `${Math.round(bytes2 / MEGABYTE * 10) / 10} MB`;
+  var emptyWalk = () => ({
+    entries: 0,
+    totalBytes: 0,
+    largest: { path: "", bytes: 0 }
+  });
+  var isSafeSegment = (name) => name !== "" && name !== "." && name !== ".." && !/[/\\]/.test(name) && // a Windows drive or a NUL byte is never a segment either
+  !/[\0]/.test(name);
+  var walk = (members, parentPath, acc, depth = 1) => {
+    for (const member of members) {
+      const name = memberName(member);
+      const memberPath = parentPath ? `${parentPath}/${name}` : name;
+      if (!isSafeSegment(name) && !acc.nameRefusal)
+        acc.nameRefusal = {
+          code: 400,
+          status: "failure",
+          message: `Invalid member name: '${name}'. Member names must be single path segments (no '/', '\\', '..').`
+        };
+      acc.entries++;
+      if (member.type === "folder") {
+        if (depth + 1 > MAX_DEPTH) {
+          if (!acc.tooDeep) acc.tooDeep = depth + 1;
+          continue;
+        }
+        walk(member.members, memberPath, acc, depth + 1);
+        continue;
+      }
+      const bytes2 = memberBytes(member);
+      acc.totalBytes += bytes2;
+      if (bytes2 > acc.largest.bytes) acc.largest = { path: memberPath, bytes: bytes2 };
+    }
+  };
+  var measureDeployTree = (members) => {
+    const acc = emptyWalk();
+    walk(members, "", acc);
+    return {
+      entries: acc.entries,
+      totalBytes: acc.totalBytes,
+      largest: acc.largest
+    };
+  };
+  var checkDeployTree = (members, limits = DEPLOY_LIMITS) => {
+    const measured = emptyWalk();
+    walk(members, "", measured);
+    if (measured.nameRefusal) return measured.nameRefusal;
+    if (measured.tooDeep)
+      return {
+        code: 413,
+        status: "failure",
+        message: `The file tree is nested too deeply: ${measured.tooDeep} levels (maximum ${MAX_DEPTH}).`
+      };
+    if (measured.entries > limits.entries)
+      return {
+        code: 413,
+        status: "failure",
+        message: `The file tree exceeds the deploy limit: ${measured.entries} entries (maximum ${limits.entries}).`
+      };
+    if (measured.totalBytes > limits.totalBytes)
+      return {
+        code: 413,
+        status: "failure",
+        message: `The file tree exceeds the deploy limit: ${describeSize(measured.totalBytes)} (maximum ${describeLimit(limits.totalBytes)}).`
+      };
+    if (measured.largest.bytes > limits.fileBytes)
+      return {
+        code: 413,
+        status: "failure",
+        message: `A file in the tree exceeds the deploy limit: ${measured.largest.path} is ${describeSize(measured.largest.bytes)} (maximum ${describeLimit(limits.fileBytes)} per file).`
+      };
+    return null;
+  };
+  var isDeployTree = (value) => {
+    if (!value || typeof value !== "object") return false;
+    const members = value.members;
+    return Array.isArray(members) && members.every(isDeployMember);
+  };
+  var isDeployMember = (value) => {
+    if (!value || typeof value !== "object") return false;
+    const member = value;
+    if (typeof member.name !== "string") return false;
+    if (member.type === "folder")
+      return Array.isArray(member.members) && member.members.every(isDeployMember);
+    if (member.type === "service" || member.type === "file")
+      return typeof member.code === "string";
+    return false;
+  };
+  var deployTree = async (store, appLoc, tree, limits = DEPLOY_LIMITS) => {
+    if (!isDeployTree(tree))
+      throw new ApiError(400, "Provided not supported data format.", {
+        status: "failure",
+        message: "Provided not supported data format."
+      });
+    const root = normaliseDrivePath(appLoc);
+    if (root === null)
+      throw new ApiError(400, "appLoc cannot be outside drive.", {
+        status: "failure",
+        message: "appLoc cannot be outside drive."
+      });
+    const refusal = checkDeployTree(tree.members, limits);
+    if (refusal)
+      throw new ApiError(refusal.code, refusal.message, {
+        status: refusal.status,
+        message: refusal.message
+      });
+    try {
+      await writeMembers(store, tree.members, root);
+    } catch {
+      throw new ApiError(500, "Deployment failed!", {
+        status: "failure",
+        message: "Deployment failed!"
+      });
+    }
+  };
+  var writeMembers = async (store, members, parentPath) => {
+    for (const member of members) {
+      const path = `${parentPath}/${memberName(member)}`;
+      if (member.type === "folder") {
+        await store.mkdirp(path);
+        await writeMembers(store, member.members, path);
+        continue;
+      }
+      await store.write(
+        path,
+        member.type === "file" ? decodeBase64(member.code) : member.code
+      );
+    }
+  };
+
   // src/drive/service.ts
   var filePath = (input, outside) => {
     const checked = checkFilePath(input);
@@ -226,6 +411,10 @@ var SASjsApi = (() => {
         const stat = await store.stat(path);
         if (!stat.directory) throw new ApiError(400, "Not a Folder.");
         return { status: "success", tree: await treeOf(path) };
+      },
+      async deploy(appLoc, tree) {
+        await deployTree(store, appLoc, tree);
+        return { status: "success" };
       }
     };
   };
@@ -816,6 +1005,10 @@ var SASjsApi = (() => {
           status: 400,
           description: "Invalid Format"
         },
+        {
+          status: 413,
+          description: "File tree exceeds the deploy limit"
+        },
         {
           status: 500,
           description: "Execution Error"
@@ -846,6 +1039,10 @@ var SASjsApi = (() => {
           status: 400,
           description: "Invalid Format"
         },
+        {
+          status: 413,
+          description: "File tree exceeds the deploy limit"
+        },
         {
           status: 500,
           description: "Execution Error"
@@ -2078,7 +2275,7 @@ var SASjsApi = (() => {
   var PERMISSIONS = "The route inventory is the host's permission model, which this package does not hold.";
   var HOST_OWNED = "The host owns this report: it describes the host's own process and files, which a browser build has no equivalent of.";
   var WEB_BUNDLE = "The host serves its own web bundle; there is no API decision here for this package to answer.";
-  var DEPLOY_CAP = "Writing a whole tree in one request can exhaust the host's storage, so the deploy routes land with the size cap that bounds it.";
+  var ARCHIVE = "Expanding the uploaded archive is the host's transport work - multer and a zip library on the server, `DecompressionStream` in a worker - and the host hands this package the tree it produces, which is the same tree `POST /SASjsApi/drive/deploy` takes.";
   var UNPUBLISH = "Unpublishing inverts the deploy route, so the two land together.";
   var success = { status: "success" };
   var user = {
@@ -2181,10 +2378,27 @@ var SASjsApi = (() => {
       implemented: true,
       responses: { 200: { status: "success", tree: {} } }
     },
-    "POST /SASjsApi/drive/deploy": { implemented: false, reason: DEPLOY_CAP },
+    // The deploy routes answer an ENVELOPE, unlike the file routes above: their
+    // `400` is `{status:'failure', message}` rather than the message as text, and
+    // `413` is the cap refusing the tree before anything is written.
+    // `"appLoc" is required` and `"fileTree" is required` are the other `400` this
+    // route sends - a missing body property, worded by the table's own
+    // validation - so the body annotated here is the substantial one.
+    "POST /SASjsApi/drive/deploy": {
+      implemented: true,
+      responses: {
+        200: DEPLOY_SUCCESS,
+        400: {
+          status: "failure",
+          message: "Provided not supported data format."
+        },
+        413: "The file tree exceeds the deploy limit.",
+        500: { status: "failure", message: "Deployment failed!" }
+      }
+    },
     "POST /SASjsApi/drive/deploy/upload": {
       implemented: false,
-      reason: DEPLOY_CAP
+      reason: ARCHIVE
     },
     // `404` is a pair - the registry name and the appLoc it was published from -
     // that matches no entry, and the drive's content is deliberately left alone.
@@ -2486,6 +2700,10 @@ var SASjsApi = (() => {
             String(request.body?.newPath || "")
           )
         };
+      case "POST /SASjsApi/drive/deploy": {
+        await drive.deploy(String(body.appLoc ?? ""), body.fileTree);
+        return { status: 200, body: DEPLOY_SUCCESS };
+      }
       case "GET /SASjsApi/drive/filetree":
         return { status: 200, body: await drive.tree(query._folderPath) };
       default: {
@@ -2507,6 +2725,7 @@ var SASjsApi = (() => {
     "DELETE /SASjsApi/drive/folder",
     "POST /SASjsApi/drive/rename",
     "GET /SASjsApi/drive/filetree",
+    "POST /SASjsApi/drive/deploy",
     "POST /SASjsApi/auth/token",
     "POST /SASjsApi/auth/refresh",
     "POST /SASjsApi/auth/logout",
@@ -2873,6 +3092,11 @@ var SASjsApi = (() => {
   // src/corpus/drive.ts
   var success2 = { status: "success" };
   var bytes = (...values) => Uint8Array.from(values);
+  var manyMembers = (count) => Array.from({ length: count }, (_, at) => ({
+    name: `f${at}.txt`,
+    type: "file",
+    code: ""
+  }));
   var DRIVE_CORPUS = [
     {
       id: "create-file",
@@ -3162,6 +3386,119 @@ var SASjsApi = (() => {
         }
       }
     },
+    {
+      id: "deploy-tree",
+      route: "POST /SASjsApi/drive/deploy",
+      description: "writes a whole tree under the appLoc it names",
+      request: {
+        body: {
+          appLoc: "/Public/apps/demo",
+          fileTree: {
+            members: [
+              {
+                name: "services",
+                type: "folder",
+                members: [{ name: "run", type: "service", code: "%put hi;" }]
+              },
+              { name: "index.html", type: "file", code: "PGgxPkhlbGxvPC9oMT4=" }
+            ]
+          }
+        }
+      },
+      expect: {
+        status: 200,
+        body: {
+          status: "success",
+          message: "Files deployed successfully to @sasjs/server."
+        }
+      }
+    },
+    {
+      id: "deploy-refused-by-entry-count",
+      route: "POST /SASjsApi/drive/deploy",
+      description: "refuses a tree over the entry cap, naming the figure and the cap",
+      request: {
+        body: {
+          appLoc: "/Public/apps/many",
+          fileTree: { members: manyMembers(10001) }
+        }
+      },
+      expect: {
+        status: 413,
+        body: {
+          status: "failure",
+          message: "The file tree exceeds the deploy limit: 10001 entries (maximum 10000)."
+        },
+        error: "The file tree exceeds the deploy limit: 10001 entries (maximum 10000)."
+      }
+    },
+    {
+      id: "deploy-refused-by-name",
+      route: "POST /SASjsApi/drive/deploy",
+      description: "refuses a member name that would escape the deployment root",
+      request: {
+        body: {
+          appLoc: "/Public/apps/hostile",
+          fileTree: {
+            members: [{ name: "../escape", type: "service", code: "%put hi;" }]
+          }
+        }
+      },
+      expect: {
+        status: 400,
+        body: {
+          status: "failure",
+          message: "Invalid member name: '../escape.sas'. Member names must be single path segments (no '/', '\\', '..')."
+        },
+        error: "Invalid member name: '../escape.sas'. Member names must be single path segments (no '/', '\\', '..')."
+      }
+    },
+    {
+      id: "deploy-refused-by-shape",
+      route: "POST /SASjsApi/drive/deploy",
+      description: "refuses a fileTree that is not a tree, in the routes own envelope",
+      request: { body: { appLoc: "/Public/apps/bad", fileTree: { members: 1 } } },
+      expect: {
+        status: 400,
+        body: {
+          status: "failure",
+          message: "Provided not supported data format."
+        },
+        error: "Provided not supported data format."
+      }
+    },
+    {
+      id: "deploy-refused-by-store",
+      route: "POST /SASjsApi/drive/deploy",
+      description: "answers the routes 500 when the drive refuses the write",
+      unwritable: true,
+      request: {
+        body: {
+          appLoc: "/Public/apps/demo",
+          fileTree: {
+            members: [{ name: "run", type: "service", code: "%put hi;" }]
+          }
+        }
+      },
+      expect: {
+        status: 500,
+        body: { status: "failure", message: "Deployment failed!" },
+        error: "Deployment failed!"
+      }
+    },
+    {
+      id: "deploy-refused-outside-drive",
+      route: "POST /SASjsApi/drive/deploy",
+      description: "refuses an appLoc that resolves outside the drive",
+      request: {
+        body: { appLoc: "/../outside", fileTree: { members: [] } }
+      },
+      expect: {
+        status: 400,
+        body: { status: "failure", message: "appLoc cannot be outside drive." },
+        error: "appLoc cannot be outside drive."
+      }
+    },
     {
       id: "bytes-round-trip",
       route: "GET /SASjsApi/drive/file",
@@ -3439,11 +3776,21 @@ var SASjsApi = (() => {
 
   // src/corpus/runner.ts
   var servicesFor = (testCase) => ({
-    drive: createDriveService(new MemoryDriveStore(testCase.seed || {})),
+    drive: createDriveService(
+      testCase.unwritable ? new RefusingDriveStore(testCase.seed || {}) : new MemoryDriveStore(testCase.seed || {})
+    ),
     identity: createIdentityService(
       new MemoryIdentityStore(testCase.identity || DEFAULT_IDENTITY)
     )
   });
+  var RefusingDriveStore = class extends MemoryDriveStore {
+    async write() {
+      throw new Error("the store refused the write");
+    }
+    async mkdirp() {
+      throw new Error("the store refused the write");
+    }
+  };
   var runCase = async (testCase, services = servicesFor(testCase)) => {
     try {
       const response = await dispatch(services, testCase.route, testCase.request);
@@ -3453,7 +3800,8 @@ var SASjsApi = (() => {
         contents: response.contents
       };
     } catch (error) {
-      if (isApiError(error)) return { status: error.status, error: error.message };
+      if (isApiError(error))
+        return { status: error.status, body: error.body, error: error.message };
       throw error;
     }
   };

package/build/cjs/corpus/drive.js

@@ -8,6 +8,12 @@ const success = { status: 'success' };
  * host that does not have one. An explicit byte array is both.
  */
 const bytes = (...values) => Uint8Array.from(values);
+/** A flat tree of `count` empty file members, for the cap's entry dimension. */
+const manyMembers = (count) => Array.from({ length: count }, (_, at) => ({
+    name: `f${at}.txt`,
+    type: 'file',
+    code: ''
+}));
 exports.DRIVE_CORPUS = [
     {
         id: 'create-file',
@@ -297,6 +303,119 @@ exports.DRIVE_CORPUS = [
             }
         }
     },
+    {
+        id: 'deploy-tree',
+        route: 'POST /SASjsApi/drive/deploy',
+        description: 'writes a whole tree under the appLoc it names',
+        request: {
+            body: {
+                appLoc: '/Public/apps/demo',
+                fileTree: {
+                    members: [
+                        {
+                            name: 'services',
+                            type: 'folder',
+                            members: [{ name: 'run', type: 'service', code: '%put hi;' }]
+                        },
+                        { name: 'index.html', type: 'file', code: 'PGgxPkhlbGxvPC9oMT4=' }
+                    ]
+                }
+            }
+        },
+        expect: {
+            status: 200,
+            body: {
+                status: 'success',
+                message: 'Files deployed successfully to @sasjs/server.'
+            }
+        }
+    },
+    {
+        id: 'deploy-refused-by-entry-count',
+        route: 'POST /SASjsApi/drive/deploy',
+        description: 'refuses a tree over the entry cap, naming the figure and the cap',
+        request: {
+            body: {
+                appLoc: '/Public/apps/many',
+                fileTree: { members: manyMembers(10001) }
+            }
+        },
+        expect: {
+            status: 413,
+            body: {
+                status: 'failure',
+                message: 'The file tree exceeds the deploy limit: 10001 entries (maximum 10000).'
+            },
+            error: 'The file tree exceeds the deploy limit: 10001 entries (maximum 10000).'
+        }
+    },
+    {
+        id: 'deploy-refused-by-name',
+        route: 'POST /SASjsApi/drive/deploy',
+        description: 'refuses a member name that would escape the deployment root',
+        request: {
+            body: {
+                appLoc: '/Public/apps/hostile',
+                fileTree: {
+                    members: [{ name: '../escape', type: 'service', code: '%put hi;' }]
+                }
+            }
+        },
+        expect: {
+            status: 400,
+            body: {
+                status: 'failure',
+                message: "Invalid member name: '../escape.sas'. Member names must be single path segments (no '/', '\\', '..')."
+            },
+            error: "Invalid member name: '../escape.sas'. Member names must be single path segments (no '/', '\\', '..')."
+        }
+    },
+    {
+        id: 'deploy-refused-by-shape',
+        route: 'POST /SASjsApi/drive/deploy',
+        description: 'refuses a fileTree that is not a tree, in the routes own envelope',
+        request: { body: { appLoc: '/Public/apps/bad', fileTree: { members: 1 } } },
+        expect: {
+            status: 400,
+            body: {
+                status: 'failure',
+                message: 'Provided not supported data format.'
+            },
+            error: 'Provided not supported data format.'
+        }
+    },
+    {
+        id: 'deploy-refused-by-store',
+        route: 'POST /SASjsApi/drive/deploy',
+        description: 'answers the routes 500 when the drive refuses the write',
+        unwritable: true,
+        request: {
+            body: {
+                appLoc: '/Public/apps/demo',
+                fileTree: {
+                    members: [{ name: 'run', type: 'service', code: '%put hi;' }]
+                }
+            }
+        },
+        expect: {
+            status: 500,
+            body: { status: 'failure', message: 'Deployment failed!' },
+            error: 'Deployment failed!'
+        }
+    },
+    {
+        id: 'deploy-refused-outside-drive',
+        route: 'POST /SASjsApi/drive/deploy',
+        description: 'refuses an appLoc that resolves outside the drive',
+        request: {
+            body: { appLoc: '/../outside', fileTree: { members: [] } }
+        },
+        expect: {
+            status: 400,
+            body: { status: 'failure', message: 'appLoc cannot be outside drive.' },
+            error: 'appLoc cannot be outside drive.'
+        }
+    },
     {
         id: 'bytes-round-trip',
         route: 'GET /SASjsApi/drive/file',

package/build/cjs/corpus/runner.js

@@ -15,10 +15,26 @@ const types_js_1 = require("../types.js");
  * mid-flow can declare the tokens and codes it begins with.
  */
 const servicesFor = (testCase) => ({
-    drive: (0, service_js_1.createDriveService)(new memory_store_js_1.MemoryDriveStore(testCase.seed || {})),
+    drive: (0, service_js_1.createDriveService)(testCase.unwritable
+        ? new RefusingDriveStore(testCase.seed || {})
+        : new memory_store_js_1.MemoryDriveStore(testCase.seed || {})),
     identity: (0, service_js_2.createIdentityService)(new memory_store_js_2.MemoryIdentityStore(testCase.identity || fixture_js_1.DEFAULT_IDENTITY))
 });
 exports.servicesFor = servicesFor;
+/**
+ * A drive that reads but refuses every write.
+ *
+ * Only the corpus uses it: `POST /drive/deploy` answers `500` when storing
+ * fails, and a case for that answer needs a store that fails.
+ */
+class RefusingDriveStore extends memory_store_js_1.MemoryDriveStore {
+    async write() {
+        throw new Error('the store refused the write');
+    }
+    async mkdirp() {
+        throw new Error('the store refused the write');
+    }
+}
 /**
  * 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
@@ -37,7 +53,7 @@ const runCase = async (testCase, services = (0, exports.servicesFor)(testCase))
         // 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 ((0, types_js_1.isApiError)(error))
-            return { status: error.status, error: error.message };
+            return { status: error.status, body: error.body, error: error.message };
         throw error;
     }
 };