@sasjs/api 0.4.0 → 0.6.0

package/build/browser.js

@@ -1,4 +1,4 @@
-/* @sasjs/api 0.4.0 - the SASjs Server API, for a service worker. https://github.com/sasjs/api */
+/* @sasjs/api 0.6.0 - 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,169 @@ 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 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 describeSize = (bytes2) => bytes2 < 1024 * 1024 ? `${bytes2} bytes` : `${Math.round(bytes2 / (1024 * 1024) * 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) => {
+    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") {
+        walk(member.members, memberPath, acc);
+        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.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 ${describeSize(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 ${describeSize(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 +398,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 +992,10 @@ var SASjsApi = (() => {
           status: 400,
           description: "Invalid Format"
         },
+        {
+          status: 413,
+          description: "File tree exceeds the deploy limit"
+        },
         {
           status: 500,
           description: "Execution Error"
@@ -846,6 +1026,10 @@ var SASjsApi = (() => {
           status: 400,
           description: "Invalid Format"
         },
+        {
+          status: 413,
+          description: "File tree exceeds the deploy limit"
+        },
         {
           status: 500,
           description: "Execution Error"
@@ -2070,6 +2254,16 @@ var SASjsApi = (() => {
     Client: ["identity"],
     Web: ["identity"]
   };
+  var IDENTITY_RECORDS = "The identity service answers the sign-in flow. User, group, permission rule, client and provider records need read and write methods on the same store, which this package does not have yet.";
+  var EDITOR = "Linting and formatting come from @sasjs/lint, which this package does not depend on. They land with the code routes so an editor has one wiring.";
+  var RUNTIME = "Starting a program needs a runtime port, which this package does not have: a host decides which languages it holds, and answers this itself until then.";
+  var SESSION_RECORD = "A triggered session's record, log, output and state belong to the runtime that ran the program, and this package has no runtime port.";
+  var HOST_CONFIG = "The body is the host's own configuration - ports, run times and providers - which a mock states for itself and this package cannot know.";
+  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 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 = {
     uid: "",
@@ -2079,11 +2273,61 @@ var SASjsApi = (() => {
     needsToUpdatePassword: false
   };
   var 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
+    // Web - the sign-in pages the identity service answers, and the bundle itself
+    "GET /": { implemented: false, reason: WEB_BUNDLE },
+    "POST /SASLogon/login": {
+      implemented: true,
+      // The lockout and the provider failure are answered before the package is
+      // consulted (routes/web/web.ts in sasjs/server).
+      hostResponses: [429, 500],
+      responses: { 200: { loggedIn: true, user } }
+    },
+    "POST /SASLogon/authorize": {
+      implemented: true,
+      responses: { 200: { code: "" } }
+    },
+    "GET /SASLogon/logout": {
+      implemented: true,
+      hostResponses: [500],
+      responses: { 200: "OK!" }
+    },
+    // Admin - the host's own process and files
+    "GET /SASjsApi/admin/diagnostics": { implemented: false, reason: HOST_OWNED },
+    "GET /SASjsApi/admin/logs": { implemented: false, reason: HOST_OWNED },
+    "GET /SASjsApi/admin/logs/{fileName}": {
+      implemented: false,
+      reason: HOST_OWNED
+    },
+    // Auth - the token flow, plus a password change the identity store cannot write
+    "POST /SASjsApi/auth/token": {
+      implemented: true,
+      responses: { 200: { accessToken: "", refreshToken: "" } }
+    },
+    "POST /SASjsApi/auth/refresh": {
+      implemented: true,
+      responses: { 200: { accessToken: "", refreshToken: "" } }
+    },
+    "POST /SASjsApi/auth/logout": { implemented: true },
+    "PATCH /SASjsApi/auth/updatePassword": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    // Auth Config - the providers a host was started with, and an LDAP import
+    "GET /SASjsApi/authConfig": { implemented: false, reason: HOST_CONFIG },
+    "POST /SASjsApi/authConfig/synchroniseWithLDAP": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    // Client - the OAuth clients the identity store already holds for sign-in
+    "GET /SASjsApi/client": { implemented: false, reason: IDENTITY_RECORDS },
+    "POST /SASjsApi/client": { implemented: false, reason: IDENTITY_RECORDS },
+    // Code - the editor's three calls, and the runtime one
+    "POST /SASjsApi/code/execute": { implemented: false, reason: RUNTIME },
+    "POST /SASjsApi/code/trigger": { implemented: false, reason: RUNTIME },
+    "POST /SASjsApi/code/lint": { implemented: false, reason: EDITOR },
+    "POST /SASjsApi/code/format": { implemented: false, reason: EDITOR },
+    // Drive - the file and folder rules, and the three deploy routes
+    // The body is the file itself, so there is nothing to annotate
     "GET /SASjsApi/drive/file": { implemented: true },
     "POST /SASjsApi/drive/file": {
       implemented: true,
@@ -2121,60 +2365,137 @@ var SASjsApi = (() => {
       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.
+    // 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: false
-    },
-    "POST /SASjsApi/drive/deploy/upload": {
-      implemented: false
-    },
-    // Unpublishing is the counterpart of the two above and lands with them: the
-    // document in sasjs/server states it (sasjs/server#543), so a host may answer
-    // it in the meantime, but this package cannot until the publish side it would
-    // invert is implemented here. The statuses are the document's; `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.
-    "DELETE /SASjsApi/drive/deploy": {
-      implemented: false
-    },
-    // The lockout and the provider failure are answered before the package is
-    // consulted (routes/web/web.ts in sasjs/server).
-    "POST /SASLogon/login": {
-      implemented: true,
-      hostResponses: [429, 500],
-      responses: { 200: { loggedIn: true, user } }
-    },
-    // The sign-in flow. The statuses are the document's; these entries state the
-    // body a client keys on, and that this package answers the operation.
-    "POST /SASjsApi/auth/token": {
-      implemented: true,
-      responses: { 200: { accessToken: "", refreshToken: "" } }
-    },
-    "POST /SASjsApi/auth/refresh": {
-      implemented: true,
-      responses: { 200: { accessToken: "", refreshToken: "" } }
-    },
-    "POST /SASjsApi/auth/logout": { implemented: true },
-    "POST /SASLogon/authorize": {
       implemented: true,
-      responses: { 200: { code: "" } }
+      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!" }
+      }
     },
-    "GET /SASLogon/logout": {
-      implemented: true,
-      hostResponses: [500],
-      responses: { 200: "OK!" }
+    "POST /SASjsApi/drive/deploy/upload": {
+      implemented: false,
+      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.
+    "DELETE /SASjsApi/drive/deploy": {
+      implemented: false,
+      reason: UNPUBLISH
+    },
+    // Group - members and the groups themselves
+    "GET /SASjsApi/group": { implemented: false, reason: IDENTITY_RECORDS },
+    "GET /SASjsApi/group/{uid}": { implemented: false, reason: IDENTITY_RECORDS },
+    "GET /SASjsApi/group/by/groupname/{name}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "POST /SASjsApi/group": { implemented: false, reason: IDENTITY_RECORDS },
+    "POST /SASjsApi/group/{groupUid}/{userUid}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "DELETE /SASjsApi/group/{groupUid}/{userUid}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "DELETE /SASjsApi/group/{uid}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    // Info - what the host is, and what this caller may use
+    "GET /SASjsApi/info": { implemented: false, reason: HOST_CONFIG },
+    "GET /SASjsApi/info/authorizedRoutes": {
+      implemented: false,
+      // the route inventory reports what the CALLER may use, so it needs an
+      // identity even though the rest of the Info tag needs nothing
+      capabilities: ["identity"],
+      reason: PERMISSIONS
+    },
+    "GET /SASjsApi/info/myAuthorizedRoutes": {
+      implemented: false,
+      capabilities: ["identity"],
+      reason: PERMISSIONS
+    },
+    // Permission - the rules the inventory above is derived from
+    "GET /SASjsApi/permission": { implemented: false, reason: IDENTITY_RECORDS },
+    "POST /SASjsApi/permission": { implemented: false, reason: IDENTITY_RECORDS },
+    "PATCH /SASjsApi/permission/{uid}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "DELETE /SASjsApi/permission/{uid}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    // Session - the caller's own session, then the record behind a triggered one
     "GET /SASjsApi/session": {
       implemented: true,
       responses: { 200: user }
+    },
+    "GET /SASjsApi/session/{sessionId}": {
+      implemented: false,
+      reason: SESSION_RECORD
+    },
+    "GET /SASjsApi/session/{sessionId}/log": {
+      implemented: false,
+      reason: SESSION_RECORD
+    },
+    "GET /SASjsApi/session/{sessionId}/output": {
+      implemented: false,
+      reason: SESSION_RECORD
+    },
+    "GET /SASjsApi/session/{sessionId}/state": {
+      implemented: false,
+      reason: SESSION_RECORD
+    },
+    // STP - a stored program, on the runtime port
+    "GET /SASjsApi/stp/execute": { implemented: false, reason: RUNTIME },
+    "POST /SASjsApi/stp/execute": { implemented: false, reason: RUNTIME },
+    "POST /SASjsApi/stp/trigger": { implemented: false, reason: RUNTIME },
+    // User - the accounts the identity store already holds for sign-in
+    "GET /SASjsApi/user": { implemented: false, reason: IDENTITY_RECORDS },
+    "GET /SASjsApi/user/{uid}": { implemented: false, reason: IDENTITY_RECORDS },
+    "GET /SASjsApi/user/by/username/{username}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "POST /SASjsApi/user": { implemented: false, reason: IDENTITY_RECORDS },
+    "PATCH /SASjsApi/user/{uid}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "PATCH /SASjsApi/user/by/username/{username}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "DELETE /SASjsApi/user/{uid}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
+    },
+    "DELETE /SASjsApi/user/by/username/{username}": {
+      implemented: false,
+      reason: IDENTITY_RECORDS
     }
   };
 
   // src/routes/index.ts
   var merge = (generated) => {
-    const overlay = OVERLAY[generated.id] || {};
+    const overlay = OVERLAY[generated.id];
+    if (!overlay)
+      throw new Error(
+        `src/routes/overlay.ts has no entry for ${generated.id}. Every operation states whether this package implements it and, when it does not, the reason it does not: add \`{ implemented: false, reason: '...' }\` until a handler exists.`
+      );
     const documented = new Map(
       generated.responses.map((r) => [r.status, r.description])
     );
@@ -2203,7 +2524,8 @@ var SASjsApi = (() => {
       responses,
       hostResponses: overlay.hostResponses || [],
       capabilities: overlay.capabilities || TAG_CAPABILITIES[generated.tag] || [],
-      implemented: overlay.implemented === true
+      implemented: overlay.implemented,
+      ...overlay.implemented ? {} : { reason: overlay.reason }
     };
   };
   var ROUTES = GENERATED_ROUTES.map(merge);
@@ -2365,10 +2687,19 @@ 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:
-        throw new ApiError(501, `This package has no handler for ${routeId}.`);
+      default: {
+        const reason = routeById(routeId)?.reason;
+        throw new ApiError(
+          501,
+          `This package has no handler for ${routeId}.${reason ? ` ${reason}` : ""}`
+        );
+      }
     }
   };
   var HANDLED_ROUTES = [
@@ -2381,6 +2712,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",
@@ -2747,6 +3079,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",
@@ -3036,6 +3373,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",
@@ -3313,11 +3763,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);
@@ -3327,7 +3787,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;
     }
   };