@sasjs/cli 6.24.2 → 6.26.0

package/build/commands/build/build.js

@@ -99,6 +99,7 @@ var file_1 = require("../../utils/file");
 var internal_1 = require("../compile/internal");
 var config_2 = require("./internal/config");
 var getLaunchPageCode_1 = require("./internal/getLaunchPageCode");
+var appManifest_1 = require("./internal/appManifest");
 var mockSite_1 = require("./internal/mockSite/mockSite");
 function build(target) {
     return __awaiter(this, void 0, void 0, function () {
@@ -241,6 +242,11 @@ function createFinalSasFiles(target) {
                             servicePackSASjs.streamLogo = streamConfig.streamLogo;
                             servicePackSASjs.streamServiceName = streamConfig.streamServiceName;
                             servicePackSASjs.streamWebFolder = streamConfig.streamWebFolder;
+                            // The deployment and the statement that it is an app travel together: the
+                            // server indexes the app from this file in the same request that writes the
+                            // files, so a publish cannot fail on its own after a deploy succeeded. It
+                            // also means the zip a CI job keeps is everything needed to publish.
+                            servicePackSASjs.fileTree = (0, appManifest_1.withAppManifest)(folderContentJSON, (0, appManifest_1.appManifest)(streamConfig));
                         }
                     }
                     finalSasFileContent = (0, utils_1.removeHeader)(finalSasFileContent);

package/build/commands/build/internal/appManifest.d.ts

@@ -0,0 +1,42 @@
+import { FileTree, StreamConfig } from '@sasjs/utils';
+/**
+ * The file, at the root of a deployment, that says the folder is an app.
+ *
+ * It carries what a deploy payload names for a stream today - the label, the
+ * folder the compiled assets are in, the logo - inside the deployment itself, so
+ * one upload can be both the deployment and the publish.
+ *
+ * **This ships ahead of the reader.** The manifest is read by `splitAppBundle` in
+ * sasjs/api (PR #65), which takes it out of the tree before the tree is written
+ * and indexes the app in the same request; no released `@sasjs/api`, `@sasjs/adapter`
+ * or `sasjs/server` knows the file yet, so until a host adopts that package the
+ * manifest is deployed as an ordinary file and the publish still comes from the
+ * payload's `streamWebFolder` / `streamServiceName`, exactly as now. The name has
+ * to match `APP_MANIFEST` in that package - `sasjs.app.json` is spelled here
+ * rather than imported because the deployment does not ship the package.
+ */
+export declare const APP_MANIFEST = "sasjs.app.json";
+export interface AppManifest {
+    /** The label the app is listed under. */
+    name?: string;
+    /** The folder under `services/` holding the compiled web app. */
+    streamWebFolder: string;
+    /** An asset inside the app, used as its tile image. */
+    logo?: string;
+}
+/**
+ * What a target's stream configuration says about the app it deploys.
+ *
+ * Only fields the deployer actually set are written: a manifest that states
+ * `"logo": undefined` is not JSON, and one that states a default the server also
+ * defaults would freeze that default into every deployment.
+ */
+export declare const appManifest: (streamConfig: StreamConfig) => AppManifest;
+/**
+ * The deployment tree with the manifest at its root.
+ *
+ * A tree that already carries a manifest - a build output adjusted by hand, or a
+ * bundle built twice - has it replaced rather than duplicated, because two files
+ * with one name in one folder is not a tree any host can deploy.
+ */
+export declare const withAppManifest: (tree: FileTree, manifest: AppManifest) => FileTree;

package/build/commands/build/internal/appManifest.js

@@ -0,0 +1,85 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAppManifest = exports.appManifest = exports.APP_MANIFEST = void 0;
+var utils_1 = require("@sasjs/utils");
+/**
+ * The file, at the root of a deployment, that says the folder is an app.
+ *
+ * It carries what a deploy payload names for a stream today - the label, the
+ * folder the compiled assets are in, the logo - inside the deployment itself, so
+ * one upload can be both the deployment and the publish.
+ *
+ * **This ships ahead of the reader.** The manifest is read by `splitAppBundle` in
+ * sasjs/api (PR #65), which takes it out of the tree before the tree is written
+ * and indexes the app in the same request; no released `@sasjs/api`, `@sasjs/adapter`
+ * or `sasjs/server` knows the file yet, so until a host adopts that package the
+ * manifest is deployed as an ordinary file and the publish still comes from the
+ * payload's `streamWebFolder` / `streamServiceName`, exactly as now. The name has
+ * to match `APP_MANIFEST` in that package - `sasjs.app.json` is spelled here
+ * rather than imported because the deployment does not ship the package.
+ */
+exports.APP_MANIFEST = 'sasjs.app.json';
+/**
+ * What a target's stream configuration says about the app it deploys.
+ *
+ * Only fields the deployer actually set are written: a manifest that states
+ * `"logo": undefined` is not JSON, and one that states a default the server also
+ * defaults would freeze that default into every deployment.
+ */
+var appManifest = function (streamConfig) { return (__assign(__assign(__assign({}, (streamConfig.streamServiceName
+    ? { name: streamConfig.streamServiceName }
+    : {})), { streamWebFolder: streamConfig.streamWebFolder }), (streamConfig.streamLogo ? { logo: streamConfig.streamLogo } : {}))); };
+exports.appManifest = appManifest;
+/**
+ * The deployment tree with the manifest at its root.
+ *
+ * A tree that already carries a manifest - a build output adjusted by hand, or a
+ * bundle built twice - has it replaced rather than duplicated, because two files
+ * with one name in one folder is not a tree any host can deploy.
+ */
+var withAppManifest = function (tree, manifest) { return (__assign(__assign({}, tree), { members: __spreadArray(__spreadArray([], __read(tree.members.filter(function (member) {
+        return !(member.type === utils_1.MemberType.file && member.name === exports.APP_MANIFEST);
+    })), false), [
+        {
+            name: exports.APP_MANIFEST,
+            type: utils_1.MemberType.file,
+            code: JSON.stringify(manifest, null, 2)
+        }
+    ], false) })); };
+exports.withAppManifest = withAppManifest;

package/build/commands/build/internal/mockSite/assets/persist.js

@@ -3,29 +3,40 @@
  *
  * The service worker hosts the runtime but may be terminated between requests,
  * so it holds no durable state. On boot this script reads the persisted drive
- * and hands it to the worker; after every service run the worker sends back the
- * files it changed and they are written here.
+ * and identity and hands them to the worker; after every service run the worker
+ * sends back the files it changed and the identity store's snapshot when a route
+ * changed it, and both are written here.
  */
 ;(function () {
   const DB_NAME = 'sasjs-mock-host'
-  const STORE = 'files'
+  const FILES = 'files'
+  /**
+   * The identity the visitor last had: the fixture the worker's store reported
+   * and the account the visitor chose to view the app as. One row, because the
+   * two are written together - a subject without the fixture it names would be a
+   * boot signed in as an account the store no longer holds.
+   */
+  const IDENTITY = 'identity'
+  const IDENTITY_KEY = 'current'
 
   const openDb = () =>
     new Promise((resolve, reject) => {
-      const req = indexedDB.open(DB_NAME, 1)
+      const req = indexedDB.open(DB_NAME, 2)
       req.onupgradeneeded = () => {
         const db = req.result
-        if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE)
+        if (!db.objectStoreNames.contains(FILES)) db.createObjectStore(FILES)
+        if (!db.objectStoreNames.contains(IDENTITY))
+          db.createObjectStore(IDENTITY)
       }
       req.onsuccess = () => resolve(req.result)
       req.onerror = () => reject(req.error)
     })
 
-  const withStore = async (mode, run) => {
+  const withStore = async (mode, run, name = FILES) => {
     const db = await openDb()
     return new Promise((resolve, reject) => {
-      const tx = db.transaction(STORE, mode)
-      const store = tx.objectStore(STORE)
+      const tx = db.transaction(name, mode)
+      const store = tx.objectStore(name)
       let result
       try {
         result = run(store)
@@ -44,15 +55,15 @@
       try {
         const db = await openDb()
         const keysReq = db
-          .transaction(STORE, 'readonly')
-          .objectStore(STORE)
+          .transaction(FILES, 'readonly')
+          .objectStore(FILES)
           .getAllKeys()
         keysReq.onsuccess = () => {
           const keys = keysReq.result
           if (!keys.length) return resolve({})
           const valsReq = db
-            .transaction(STORE, 'readonly')
-            .objectStore(STORE)
+            .transaction(FILES, 'readonly')
+            .objectStore(FILES)
             .getAll()
           valsReq.onsuccess = () => {
             const files = {}
@@ -89,6 +100,36 @@
 
   const clearAll = () => withStore('readwrite', (store) => store.clear())
 
+  /**
+   * The stored identity, `null` when there is none. A row whose shape is not the
+   * one this script writes is ignored rather than handed on: the worker refuses a
+   * fixture it cannot read by name, and re-sending a value that is not a row at
+   * all would blame the fixture for a corrupt database.
+   */
+  const readIdentity = () =>
+    new Promise(async (resolve, reject) => {
+      try {
+        const db = await openDb()
+        const req = db
+          .transaction(IDENTITY, 'readonly')
+          .objectStore(IDENTITY)
+          .get(IDENTITY_KEY)
+        req.onsuccess = () => {
+          const row = req.result
+          resolve(row && typeof row === 'object' && row.fixture ? row : null)
+        }
+        req.onerror = () => reject(req.error)
+      } catch (e) {
+        reject(e)
+      }
+    })
+
+  const writeIdentity = (row) =>
+    withStore('readwrite', (store) => store.put(row, IDENTITY_KEY), IDENTITY)
+
+  const clearIdentity = () =>
+    withStore('readwrite', (store) => store.delete(IDENTITY_KEY), IDENTITY)
+
   /**
    * The build this site is, as the page can see it: mock-config.json carries the
    * stamp the build wrote over its host code and the seed it lays out. Read here
@@ -191,13 +232,29 @@
       })
     })
 
-  // Persist whatever the worker reports as changed.
+  // Persist whatever the worker reports as changed: drive files, and the
+  // identity store's snapshot when a route created, changed or removed anything.
   navigator.serviceWorker.addEventListener('message', (ev) => {
     const data = ev.data || {}
-    if (data.type === 'sasjs-persist')
+    if (data.type === 'sasjs-persist') {
       writeFiles(data.files).catch((e) =>
         console.error('[sasjs-mock] persist failed', e)
       )
+      if (data.identity)
+        readIdentity()
+          .then((row) =>
+            // `undefined`, not null: no stored subject means the fixture's own
+            // administrator, which is not the same as the anonymous caller a
+            // null would name
+            writeIdentity({
+              fixture: data.identity,
+              subject: row ? row.subject : undefined
+            })
+          )
+          .catch((e) =>
+            console.error('[sasjs-mock] identity persist failed', e)
+          )
+    }
     if (data.type === 'sasjs-host-error')
       console.error('[sasjs-mock] ' + data.path + ': ' + data.message)
   })
@@ -206,7 +263,52 @@
     readAll,
     writeFiles,
     clear: clearAll,
+    identity: readIdentity,
     snapshot: () => askWorker({ type: 'sasjs-snapshot' }, 'sasjs-snapshot'),
+    /**
+     * Views the app as another account: `as('sasjsuser')` for a restricted user,
+     * `as()` or `as('admin')` to return to the fixture's administrator.
+     *
+     * The worker issues a token pair for the account and answers as it from then
+     * on; the subject and the fixture are stored here so a reload stays that
+     * account, and the app is restarted so every screen redraws its menus and
+     * refusals. The pair is returned for a caller who wants to send it as a
+     * bearer token - nothing signs it, and no password is checked.
+     */
+    as: async (username) => {
+      const answer = await askWorker(
+        { type: 'sasjs-as', username },
+        'sasjs-as-ack'
+      )
+      if (answer.error) throw new Error(answer.error)
+
+      try {
+        await writeIdentity({
+          fixture: answer.identity,
+          subject: answer.username
+        })
+      } catch (e) {
+        // the subject still applies to this run; it just will not outlive it
+        console.error('[sasjs-mock] could not store the subject: ' + e)
+      }
+
+      const pair = {
+        username: answer.username,
+        accessToken: answer.accessToken,
+        refreshToken: answer.refreshToken
+      }
+
+      // a task, so the caller's promise resolves with the pair first
+      setTimeout(() => {
+        try {
+          window.location.reload()
+        } catch (e) {
+          /* a page that cannot reload keeps the subject it already has */
+        }
+      }, 0)
+
+      return pair
+    },
     /**
      * The drive total in bytes, measured by the worker: it owns the stored
      * representation, so the figure stays the one `statSync` reports rather than
@@ -249,20 +351,62 @@
       return Object.keys(files).length
     },
     reset: async () => {
-      await askWorker({ type: 'sasjs-reset' }, 'sasjs-reset-ack')
+      const answer = await askWorker({ type: 'sasjs-reset' }, 'sasjs-reset-ack')
+      if (answer.error) throw new Error(answer.error)
       await clearAll()
+      await clearIdentity()
       return true
     }
   }
 
+  /**
+   * Boots the worker with what is stored, and recovers when the stored identity
+   * is one this build cannot read.
+   *
+   * A fixture outlives the build that wrote it, exactly as the drive does, and
+   * the worker refuses one whose format stamp it does not speak - by name, and
+   * with `errorKind: 'identity'`. Only that answer drops the stored row: the
+   * row holds the accounts the visitor created as well as the fixture, so a
+   * host-side failure (a drive that could not be read) leaves it alone.
+   */
+  const boot = async (files, stored) => {
+    const loading = Object.keys(files).length > 0
+    const type = loading ? 'sasjs-load' : 'sasjs-seed'
+    const ack = loading ? 'sasjs-load-ack' : 'sasjs-seed-ack'
+
+    const answer = await askWorker(
+      {
+        type,
+        files,
+        identity: stored ? stored.fixture : undefined,
+        subject: stored ? stored.subject : undefined
+      },
+      ack
+    )
+
+    if (answer.error && stored && answer.errorKind === 'identity') {
+      console.info('[sasjs-mock] ' + answer.error)
+      try {
+        await clearIdentity()
+      } catch (e) {
+        console.error('[sasjs-mock] could not clear the stored identity: ' + e)
+      }
+      return await askWorker({ type, files }, ack)
+    }
+
+    return answer
+  }
+
   window.__sasjsMockReady = (async () => {
     await navigator.serviceWorker.ready
     const controller = await waitForController()
     if (!controller) return { error: 'no service worker controller' }
 
     let files = {}
+    let stored = null
     try {
       files = await readAll()
+      stored = await readIdentity()
     } catch (e) {
       console.error('[sasjs-mock] could not read storage: ' + e)
     }
@@ -287,23 +431,18 @@
       )
       try {
         await clearAll()
+        // the identity is part of what this build ships, so a visitor who kept
+        // the previous build's fixture would never see a changed
+        // `mock-identity.json`: it goes with the drive, as it does on reset
+        await clearIdentity()
       } catch (e) {
         console.error('[sasjs-mock] could not clear storage: ' + e)
       }
       files = {}
+      stored = null
     }
 
-    if (Object.keys(files).length) {
-      window.__sasjsMockBoot = await askWorker(
-        { type: 'sasjs-load', files },
-        'sasjs-load-ack'
-      )
-    } else {
-      window.__sasjsMockBoot = await askWorker(
-        { type: 'sasjs-seed' },
-        'sasjs-seed-ack'
-      )
-    }
+    window.__sasjsMockBoot = await boot(files, stored)
     if (window.__sasjsMockBoot && !window.__sasjsMockBoot.error)
       keepBuildStamp(stamp)
     return window.__sasjsMockBoot