@sasjs/api 0.2.0 → 0.3.0

package/build/cjs/identity/memory-store.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryIdentityStore = void 0;
+const fixture_js_1 = require("./fixture.js");
+const types_js_1 = require("../types.js");
+const keyOf = (subject) => `${subject.userId}|${subject.clientId}`;
+/**
+ * Opaque identity strings, from the platform's cryptographic source.
+ *
+ * These strings are credentials: whoever holds one is the caller it names. A
+ * counter or `Math.random` is a sequence a reader can reproduce, so it would
+ * let one caller name another - the store is small and demo-shaped, but a token
+ * that can be guessed is not a demo quirk, it is an authentication bypass.
+ *
+ * `globalThis.crypto` is present in every browser and in Node from 19, which is
+ * the same reach the rest of this package has (no node imports, so the browser
+ * build bundles it unchanged).
+ */
+const randomHex = (bytes) => {
+    const source = globalThis.crypto;
+    if (!source)
+        throw new types_js_1.ApiError(500, 'This host has no Web Crypto (`globalThis.crypto`), so it cannot mint an unguessable identity string.');
+    const buffer = new Uint8Array(bytes);
+    source.getRandomValues(buffer);
+    return Array.from(buffer, (byte) => byte.toString(16).padStart(2, '0')).join('');
+};
+/**
+ * How long a code buys tokens, in seconds.
+ *
+ * The same lifetime `sasjs/server` signs into its auth code JWT, so a code a
+ * mock issues and one a server issues age out together.
+ */
+const CODE_LIFETIME_SECONDS = 30;
+const live = (issued, now) => issued && (issued.expiresAt === undefined || issued.expiresAt > now)
+    ? issued.subject
+    : undefined;
+/**
+ * Whether a token minted for one subject names the same user and client.
+ *
+ * The fixture can declare a token that outlives the map it is seeded into, so
+ * the read paths compare rather than trust the reference.
+ */
+class MemoryIdentityStore {
+    constructor(fixture = fixture_js_1.DEFAULT_IDENTITY) {
+        this.users = [];
+        this.passwords = new Map();
+        this.clients = new Map();
+        this.pairs = new Map();
+        this.access = new Map();
+        this.refresh = new Map();
+        this.codes = new Map();
+        this.claimed = new Set();
+        if (fixture.format !== fixture_js_1.IDENTITY_FORMAT)
+            throw new types_js_1.ApiError(500, `The identity fixture states format ${String(fixture.format)}; this store reads ${fixture_js_1.IDENTITY_FORMAT}.`);
+        for (const user of fixture.users) {
+            this.users.push({
+                uid: user.uid,
+                username: user.username,
+                displayName: user.displayName,
+                isAdmin: user.isAdmin,
+                isActive: user.isActive,
+                needsToUpdatePassword: user.needsToUpdatePassword
+            });
+            this.passwords.set(user.uid, user.password);
+        }
+        for (const client of fixture.clients)
+            this.clients.set(client.clientId, {
+                clientId: client.clientId,
+                accessTokenExpiration: client.accessTokenExpiration,
+                refreshTokenExpiration: client.refreshTokenExpiration
+            });
+        for (const token of fixture.tokens || []) {
+            const user = this.users.find((candidate) => candidate.username === token.username);
+            if (!user)
+                continue;
+            const subject = { userId: user.uid, clientId: token.clientId };
+            if (token.accessToken)
+                this.access.set(token.accessToken, { subject });
+            if (token.refreshToken)
+                this.refresh.set(token.refreshToken, { subject });
+            // a seeded token is the subject's live pair, which is what makes it
+            // authenticate: the read paths check the pair, not the token alone
+            if (token.accessToken && token.refreshToken)
+                this.pairs.set(keyOf(subject), {
+                    accessToken: token.accessToken,
+                    refreshToken: token.refreshToken
+                });
+        }
+        for (const code of fixture.codes || []) {
+            const user = this.users.find((candidate) => candidate.username === code.username);
+            if (!user)
+                continue;
+            this.codes.set(code.code, {
+                subject: { userId: user.uid, clientId: code.clientId }
+            });
+        }
+    }
+    async userByName(username) {
+        return this.users.find((user) => user.username === username);
+    }
+    async userById(uid) {
+        return this.users.find((user) => user.uid === uid);
+    }
+    /** A fixture holds the password in clear, so the check is an equality. */
+    async passwordMatches(user, password) {
+        return this.passwords.get(user.uid) === password;
+    }
+    async client(clientId) {
+        return this.clients.get(clientId);
+    }
+    async issue(subject, client) {
+        // The lifetimes are the client's, recorded against the instant of issue: a
+        // token's expiry is a fact about this pair, so the read paths can answer
+        // "invalid or expired" rather than carrying a number nothing compares.
+        const issuedAt = Date.now();
+        const pair = {
+            accessToken: `access-${randomHex(16)}`,
+            refreshToken: `refresh-${randomHex(16)}`
+        };
+        this.access.set(pair.accessToken, {
+            subject,
+            expiresAt: issuedAt + client.accessTokenExpiration * 1000
+        });
+        this.refresh.set(pair.refreshToken, {
+            subject,
+            expiresAt: issuedAt + client.refreshTokenExpiration * 1000
+        });
+        return pair;
+    }
+    /**
+     * A token names its subject only while that subject's CURRENT pair holds it.
+     * The server verifies a token against the pair saved for the user and client,
+     * so a logged-out or rotated token stops working there too; without the same
+     * check here, the browser host would honour a token the server had revoked.
+     */
+    async readAccess(token) {
+        return this.current(token, this.access, 'accessToken');
+    }
+    async readRefresh(token) {
+        return this.current(token, this.refresh, 'refreshToken');
+    }
+    current(token, issued, kind) {
+        const entry = issued.get(token);
+        if (!entry)
+            return undefined;
+        const subject = live(entry, Date.now());
+        if (!subject)
+            return undefined;
+        const pair = this.pairs.get(keyOf(subject));
+        return pair && pair[kind] === token ? subject : undefined;
+    }
+    async pairFor(subject) {
+        return this.pairs.get(keyOf(subject));
+    }
+    async savePair(subject, pair) {
+        this.pairs.set(keyOf(subject), pair);
+    }
+    async deletePair(subject) {
+        this.pairs.delete(keyOf(subject));
+    }
+    async issueCode(subject) {
+        const code = `code-${randomHex(16)}`;
+        this.codes.set(code, {
+            subject,
+            expiresAt: Date.now() + CODE_LIFETIME_SECONDS * 1000
+        });
+        return code;
+    }
+    async readCode(code) {
+        return live(this.codes.get(code), Date.now());
+    }
+    async claimCode(code) {
+        if (this.claimed.has(code) || !this.codes.has(code))
+            return false;
+        this.claimed.add(code);
+        return true;
+    }
+}
+exports.MemoryIdentityStore = MemoryIdentityStore;

package/build/cjs/identity/service.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asSession = exports.createIdentityService = void 0;
+/**
+ * The sign-in flow's decisions: what each route answers, in which order, with
+ * which wording.
+ *
+ * The transport stays with the host - a session cookie and a CSRF token on a
+ * server, whatever the browser build holds - so nothing here reads a request.
+ * A host resolves the caller (a bearer token through `authenticate`, a session
+ * it already has) and passes the subject in; the service decides whether that
+ * is enough for the operation to proceed.
+ */
+const types_js_1 = require("../types.js");
+const unauthorized = () => new types_js_1.ApiError(401, 'Unauthorized');
+/**
+ * The subject, provided the account behind it may still hold a token.
+ *
+ * `authenticate` reads a token on every request and refuses a deactivated
+ * account; an exchange or a refresh that skipped the same check would mint a
+ * fresh pair for exactly that account, so the check sits beside every path that
+ * reaches `store.issue`.
+ */
+const liveSubject = async (store, subject) => {
+    const user = await store.userById(subject.userId);
+    if (!user || !user.isActive)
+        throw unauthorized();
+    return subject;
+};
+const createIdentityService = (store) => ({
+    async authenticate(token) {
+        if (token === undefined)
+            return undefined;
+        const subject = await store.readAccess(token);
+        if (!subject)
+            return undefined;
+        // A token names a user who may since have been deactivated. sasjs/server
+        // checks `isActive` on every request, so a token that outlived the account
+        // must stop resolving here too - otherwise the browser host honours a
+        // caller the server would refuse.
+        const user = await store.userById(subject.userId);
+        return user && user.isActive ? subject : undefined;
+    },
+    async login({ username, password }) {
+        const user = await store.userByName(username);
+        // An unknown username and a wrong password answer with different messages
+        // on purpose: the server's login form tells the caller which one it was,
+        // and the account lockout - the defence against guessing - is the host's.
+        if (!user)
+            throw new types_js_1.ApiError(401, 'Username is not found.');
+        if (!(await store.passwordMatches(user, password)))
+            throw new types_js_1.ApiError(401, 'Invalid Password.');
+        // Checked after the password, so the answer is not a way to learn that an
+        // account exists but is switched off without knowing its password.
+        if (!user.isActive)
+            throw new types_js_1.ApiError(401, 'This account is not active.');
+        return {
+            loggedIn: true,
+            user: {
+                uid: user.uid,
+                username: user.username,
+                displayName: user.displayName,
+                isAdmin: user.isAdmin,
+                needsToUpdatePassword: user.needsToUpdatePassword
+            }
+        };
+    },
+    async authorize(subject, clientId) {
+        // The same answer the server's middleware gives a caller with no token: the
+        // two hosts must not describe the same refusal differently.
+        if (!subject)
+            throw unauthorized();
+        if (!(await store.client(clientId)))
+            throw new types_js_1.ApiError(403, 'Invalid clientId.');
+        return store.issueCode({ userId: subject.userId, clientId });
+    },
+    async token({ clientId, code }) {
+        // Read before claiming: a code presented with another client is refused
+        // with the same answer as one that does not verify, and it is not spent, so
+        // the caller can still exchange it for the client it was issued for.
+        const subject = await store.readCode(code);
+        if (!subject || subject.clientId !== clientId)
+            throw new types_js_1.ApiError(401, 'Invalid Auth Code');
+        // The client is read before the code is spent and before an existing pair is
+        // handed back: both the pair and the tokens it would buy belong to the
+        // client, so a client deleted since the code was issued refuses the
+        // exchange - and refuses it without consuming the code.
+        const client = await store.client(clientId);
+        if (!client)
+            throw new types_js_1.ApiError(401, 'Invalid clientId.');
+        const named = await liveSubject(store, subject);
+        if (!(await store.claimCode(code)))
+            throw new types_js_1.ApiError(401, 'Invalid Auth Code');
+        // Re-exchanging a code for the same user and client while a valid pair
+        // exists returns that pair: another tab holding the old tokens must not be
+        // signed out by a second exchange.
+        const existing = await store.pairFor(named);
+        if (existing)
+            return existing;
+        const pair = await store.issue(named, client);
+        await store.savePair(named, pair);
+        return pair;
+    },
+    async refresh(token) {
+        const subject = token === undefined ? undefined : await store.readRefresh(token);
+        if (!subject)
+            throw unauthorized();
+        const client = await store.client(subject.clientId);
+        if (!client)
+            throw new types_js_1.ApiError(401, 'Invalid clientId.');
+        const named = await liveSubject(store, subject);
+        const pair = await store.issue(named, client);
+        await store.savePair(named, pair);
+        return pair;
+    },
+    async logout(subject) {
+        if (!subject)
+            throw unauthorized();
+        await store.deletePair(subject);
+    },
+    async logoutSession() {
+        return 'OK!';
+    },
+    async session(subject) {
+        if (!subject)
+            throw unauthorized();
+        const user = await store.userById(subject.userId);
+        if (!user)
+            throw unauthorized();
+        return (0, exports.asSession)(user);
+    }
+});
+exports.createIdentityService = createIdentityService;
+/** A subject, as the session route reports it. */
+const asSession = (user) => ({
+    uid: user.uid,
+    username: user.username,
+    displayName: user.displayName,
+    isAdmin: user.isAdmin,
+    needsToUpdatePassword: user.needsToUpdatePassword
+});
+exports.asSession = asSession;

package/build/cjs/identity/types.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * The identity the API works over, as a host supplies it.
+ *
+ * A server holds users in a database, verifies a bcrypt hash and signs JWTs; a
+ * browser build holds a seeded fixture, compares a plain-text demo password and
+ * mints opaque strings. Those differences are the host's, so they live behind
+ * this port - the statuses, the messages and the order of the checks are the
+ * service's, and both hosts run the same corpus over them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.servicesFor = exports.runCase = exports.DRIVE_CORPUS = exports.HANDLED_ROUTES = exports.dispatch = exports.TAG_CAPABILITIES = exports.OVERLAY = exports.findRoute = exports.routeById = exports.ROUTES = exports.MemoryDriveStore = exports.createDriveService = exports.isRoot = exports.basename = exports.dirname = exports.hasBlockedExtension = exports.normaliseDrivePath = void 0;
+exports.servicesFor = exports.runCase = exports.IDENTITY_CORPUS = exports.DRIVE_CORPUS = exports.parseIdentity = exports.IDENTITY_FORMAT = exports.DEFAULT_IDENTITY = exports.MemoryIdentityStore = exports.createIdentityService = exports.HANDLED_ROUTES = exports.dispatch = exports.TAG_CAPABILITIES = exports.OVERLAY = exports.findRoute = exports.routeById = exports.ROUTES = exports.MemoryDriveStore = exports.createDriveService = exports.isRoot = exports.basename = exports.dirname = exports.hasBlockedExtension = exports.normaliseDrivePath = void 0;
 /**
  * `@sasjs/api` - the SASjs Server API described once.
  *
@@ -51,8 +51,18 @@ Object.defineProperty(exports, "TAG_CAPABILITIES", { enumerable: true, get: func
 var dispatch_js_1 = require("./host/dispatch.js");
 Object.defineProperty(exports, "dispatch", { enumerable: true, get: function () { return dispatch_js_1.dispatch; } });
 Object.defineProperty(exports, "HANDLED_ROUTES", { enumerable: true, get: function () { return dispatch_js_1.HANDLED_ROUTES; } });
+var service_js_2 = require("./identity/service.js");
+Object.defineProperty(exports, "createIdentityService", { enumerable: true, get: function () { return service_js_2.createIdentityService; } });
+var memory_store_js_2 = require("./identity/memory-store.js");
+Object.defineProperty(exports, "MemoryIdentityStore", { enumerable: true, get: function () { return memory_store_js_2.MemoryIdentityStore; } });
+var fixture_js_1 = require("./identity/fixture.js");
+Object.defineProperty(exports, "DEFAULT_IDENTITY", { enumerable: true, get: function () { return fixture_js_1.DEFAULT_IDENTITY; } });
+Object.defineProperty(exports, "IDENTITY_FORMAT", { enumerable: true, get: function () { return fixture_js_1.IDENTITY_FORMAT; } });
+Object.defineProperty(exports, "parseIdentity", { enumerable: true, get: function () { return fixture_js_1.parseIdentity; } });
 var drive_js_1 = require("./corpus/drive.js");
 Object.defineProperty(exports, "DRIVE_CORPUS", { enumerable: true, get: function () { return drive_js_1.DRIVE_CORPUS; } });
+var identity_js_1 = require("./corpus/identity.js");
+Object.defineProperty(exports, "IDENTITY_CORPUS", { enumerable: true, get: function () { return identity_js_1.IDENTITY_CORPUS; } });
 var runner_js_1 = require("./corpus/runner.js");
 Object.defineProperty(exports, "runCase", { enumerable: true, get: function () { return runner_js_1.runCase; } });
 Object.defineProperty(exports, "servicesFor", { enumerable: true, get: function () { return runner_js_1.servicesFor; } });

package/build/cjs/routes/generated.js

@@ -87,6 +87,10 @@ exports.GENERATED_ROUTES = [
             {
                 status: 204,
                 description: 'No content'
+            },
+            {
+                status: 401,
+                description: 'No valid access token was supplied'
             }
         ]
     },
@@ -102,6 +106,10 @@ exports.GENERATED_ROUTES = [
             {
                 status: 200,
                 description: 'Ok'
+            },
+            {
+                status: 401,
+                description: 'The refresh token is missing, invalid or expired, or the client id is unknown'
             }
         ]
     },
@@ -130,6 +138,14 @@ exports.GENERATED_ROUTES = [
             {
                 status: 200,
                 description: 'Ok'
+            },
+            {
+                status: 400,
+                description: 'The request body is missing `clientId` or `code`'
+            },
+            {
+                status: 401,
+                description: 'The authorization code is invalid, expired, already used, or was issued for another client, or the client id is unknown'
             }
         ]
     },
@@ -158,6 +174,26 @@ exports.GENERATED_ROUTES = [
             {
                 status: 204,
                 description: 'No content'
+            },
+            {
+                status: 400,
+                description: 'The request body is missing `currentPassword` or `newPassword`'
+            },
+            {
+                status: 401,
+                description: 'No valid access token was supplied'
+            },
+            {
+                status: 403,
+                description: 'The current password is incorrect'
+            },
+            {
+                status: 404,
+                description: 'The authenticated user no longer exists'
+            },
+            {
+                status: 405,
+                description: 'The account authenticates through an external provider, which holds its password'
             }
         ]
     },
@@ -1071,6 +1107,10 @@ exports.GENERATED_ROUTES = [
             {
                 status: 200,
                 description: 'Ok'
+            },
+            {
+                status: 401,
+                description: 'No valid access token or session was supplied'
             }
         ]
     },
@@ -1554,6 +1594,18 @@ exports.GENERATED_ROUTES = [
             {
                 status: 200,
                 description: 'Ok'
+            },
+            {
+                status: 400,
+                description: 'The request body is missing `clientId`, or the CSRF token is missing or invalid'
+            },
+            {
+                status: 401,
+                description: 'No signed-in session'
+            },
+            {
+                status: 403,
+                description: 'The client id is unknown'
             }
         ]
     },
@@ -1582,6 +1634,22 @@ exports.GENERATED_ROUTES = [
             {
                 status: 200,
                 description: 'Ok'
+            },
+            {
+                status: 400,
+                description: 'The request body is missing `username` or `password`'
+            },
+            {
+                status: 401,
+                description: 'The credentials are not valid, or password sign-in is disabled for local accounts'
+            },
+            {
+                status: 429,
+                description: 'Too many failed attempts for this account'
+            },
+            {
+                status: 500,
+                description: 'An unexpected error occurred while signing in'
             }
         ]
     },
@@ -1597,6 +1665,10 @@ exports.GENERATED_ROUTES = [
             {
                 status: 200,
                 description: 'Ok'
+            },
+            {
+                status: 500,
+                description: 'The session store failed to replace the session'
             }
         ]
     }

package/build/cjs/routes/index.js

@@ -36,9 +36,15 @@ const merge = (generated) => {
             ...(body === undefined ? {} : { body })
         };
     });
+    // A host-only status has to be one the document states: the annotation marks
+    // where a status is answered, it does not add one.
+    for (const status of overlay.hostResponses || [])
+        if (!documented.has(status))
+            throw new Error(`src/routes/overlay.ts marks status ${status} of ${generated.id} as host-only, and the OpenAPI document does not state it. Correct the document in sasjs/server and re-vendor spec/swagger.yaml, or drop the annotation.`);
     return {
         ...generated,
         responses,
+        hostResponses: overlay.hostResponses || [],
         capabilities: overlay.capabilities || overlay_js_1.TAG_CAPABILITIES[generated.tag] || [],
         implemented: overlay.implemented === true
     };

package/build/cjs/routes/overlay.js

@@ -18,6 +18,13 @@ exports.TAG_CAPABILITIES = {
     Web: ['identity']
 };
 const success = { status: 'success' };
+const user = {
+    uid: '',
+    username: '',
+    displayName: '',
+    isAdmin: false,
+    needsToUpdatePassword: false
+};
 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
@@ -69,6 +76,37 @@ exports.OVERLAY = {
     },
     'POST /SASjsApi/drive/deploy/upload': {
         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: '' } }
+    },
+    'GET /SASLogon/logout': {
+        implemented: true,
+        hostResponses: [500],
+        responses: { 200: 'OK!' }
+    },
+    'GET /SASjsApi/session': {
+        implemented: true,
+        responses: { 200: user }
     }
 };
 /** Every method the table may state, in the order a diff reads best. */

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

@@ -12,6 +12,7 @@
  * records each place the two disagree.
  */
 import type { ApiRequest } from '../host/dispatch.js';
+import type { IdentityFixture } from '../identity/fixture.js';
 export interface CorpusCase {
     /** Stable name, used as the test's title. */
     id: string;
@@ -20,6 +21,8 @@ export interface CorpusCase {
     description: string;
     /** Files the case starts from. */
     seed?: Record<string, string | Uint8Array>;
+    /** The identity the case starts from; the default fixture when omitted. */
+    identity?: IdentityFixture;
     request: ApiRequest;
     expect: {
         status: number;
@@ -27,6 +30,17 @@ export interface CorpusCase {
         contents?: string | Uint8Array;
         /** The refusal's message, where the case expects one. */
         error?: string;
+        /**
+         * The properties a body must carry, where the host mints the rest - a user's
+         * `uid` is the host's identifier, so a case pinning one would be pinning a
+         * fixture value into the contract.
+         */
+        partial?: Record<string, unknown>;
+        /**
+         * The properties a body must carry, where the values are the host's - a
+         * minted token is not a value a case can state.
+         */
+        keys?: string[];
     };
 }
 export declare const DRIVE_CORPUS: CorpusCase[];

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

@@ -1 +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"}
+{"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;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D,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,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,eAAe,CAAA;IAC1B,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;QACd;;;;WAIG;QACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACjC;;;WAGG;QACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAChB,CAAA;CACF;AAWD,eAAO,MAAM,YAAY,EAAE,UAAU,EA8SpC,CAAA"}

package/build/esm/corpus/drive.js

@@ -235,6 +235,26 @@ export const DRIVE_CORPUS = [
         request: { body: { oldPath: '/data/nope.csv', newPath: '/data/x.csv' } },
         expect: { status: 404, error: 'No file/folder found for provided path.' }
     },
+    {
+        id: 'rename-file-to-blocked-extension',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'refuses a rename that would produce a name the file routes refuse',
+        seed: { '/data/report.csv': 'a,b' },
+        request: {
+            body: { oldPath: '/data/report.csv', newPath: '/data/report.sh' }
+        },
+        expect: { status: 400, error: 'Invalid file extension' }
+    },
+    {
+        id: 'rename-folder-to-dotted-name',
+        route: 'POST /SASjsApi/drive/rename',
+        description: 'renames a folder whose new name carries a blocked suffix',
+        seed: { '/data/reports/a.csv': 'a' },
+        request: {
+            body: { oldPath: '/data/reports', newPath: '/data/reports.sh' }
+        },
+        expect: { status: 200, body: { status: 'success' } }
+    },
     {
         id: 'rename-folder-into-itself',
         route: 'POST /SASjsApi/drive/rename',

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

@@ -0,0 +1,17 @@
+/**
+ * The sign-in flow's conformance corpus.
+ *
+ * A case names an operation, the request a client would make, the identity the
+ * host starts from, and the answer the caller expects. Where the answer carries
+ * a value the host mints - a token, a code - the case states the properties
+ * instead, because the value is the host's and asserting it would pin one host's
+ * cryptography into the contract.
+ */
+import type { CorpusCase } from './drive.js';
+import { type IdentityFixture } from '../identity/fixture.js';
+/** The default fixture, plus a caller that is already signed in. */
+export declare const SIGNED_IN: IdentityFixture;
+/** The same identity, with the restricted user switched off. */
+export declare const DEACTIVATED: IdentityFixture;
+export declare const IDENTITY_CORPUS: CorpusCase[];
+//# sourceMappingURL=identity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../src/corpus/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE/E,oEAAoE;AACpE,eAAO,MAAM,SAAS,EAAE,eA2BvB,CAAA;AAED,gEAAgE;AAChE,eAAO,MAAM,WAAW,EAAE,eAKzB,CAAA;AAUD,eAAO,MAAM,eAAe,EAAE,UAAU,EAkOvC,CAAA"}