@sasjs/cli 6.0.0 → 6.2.0

package/build/commands/build/build.js

@@ -100,12 +100,13 @@ var compile_1 = require("../compile/compile");
 var internal_1 = require("../compile/internal");
 var config_2 = require("./internal/config");
 var getLaunchPageCode_1 = require("./internal/getLaunchPageCode");
+var mockSite_1 = require("./internal/mockSite/mockSite");
 function build(target) {
     return __awaiter(this, void 0, void 0, function () {
         var macroCorePath, _a;
-        var _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
                     macroCorePath = process.sasjsConstants.macroCorePath;
                     if (macroCorePath === '') {
@@ -120,18 +121,27 @@ function build(target) {
                     if (!_a) return [3 /*break*/, 2];
                     return [4 /*yield*/, (0, utils_1.folderExists)(process.sasjsConstants.buildDestinationFolder)];
                 case 1:
-                    _a = !(_c.sent());
-                    _c.label = 2;
+                    _a = !(_d.sent());
+                    _d.label = 2;
                 case 2:
                     if (!_a) return [3 /*break*/, 4];
                     return [4 /*yield*/, (0, compile_1.compile)(target)];
                 case 3:
-                    _c.sent();
-                    _c.label = 4;
-                case 4: return [4 /*yield*/, createFinalSasFiles(target)];
+                    _d.sent();
+                    _d.label = 4;
+                case 4: return [4 /*yield*/, createFinalSasFiles(target)
+                    // streamConfig.mockWeb opts the target into a static site that runs the same
+                    // services in a browser. It is built from what compile just produced, so it
+                    // is only meaningful after the tree above exists.
+                ];
                 case 5:
-                    _c.sent();
-                    return [2 /*return*/];
+                    _d.sent();
+                    if (!((_c = target.streamConfig) === null || _c === void 0 ? void 0 : _c.mockWeb)) return [3 /*break*/, 7];
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target)];
+                case 6:
+                    _d.sent();
+                    _d.label = 7;
+                case 7: return [2 /*return*/];
             }
         });
     });

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

@@ -0,0 +1,172 @@
+/**
+ * Page-side bridge for the browser build.
+ *
+ * The real work happens in the service worker (see /sw.js), so every request
+ * still goes over the network layer and is visible in DevTools > Network as
+ * "(from ServiceWorker)" - request payload and response body included.
+ *
+ * Two things are this file's job:
+ *   1. XHR bodies are multipart (the adapter always sends them that way).
+ *      Reading multipart inside a worker is unreliable for XHR-originated
+ *      requests, so the payload is converted to JSON here, where reading a
+ *      FormData is trivial.
+ *   2. The XHR object the app is holding must behave like a normal one: status,
+ *      readyState, responseText and real load events.
+ */
+;(function () {
+  if (window.__sasjsMockBridgeInstalled) return
+  window.__sasjsMockBridgeInstalled = true
+
+  // Set localStorage sasjsMockDebug='1' and reload to see this bridge's traffic
+  // in the console.
+  const DEBUG = (() => {
+    try {
+      return localStorage.getItem('sasjsMockDebug') === '1'
+    } catch (e) {
+      return false
+    }
+  })()
+
+  const dbg = (...args) => {
+    if (DEBUG) console.log('[sasjs-mock]', ...args)
+  }
+
+  const readBody = async (body) => {
+    const params = {}
+    const tables = []
+    if (!body) return { params, tables }
+
+    if (typeof FormData !== 'undefined' && body instanceof FormData) {
+      for (const [key, value] of body.entries()) {
+        if (typeof value === 'string') params[key] = value
+        else
+          tables.push({
+            name: key,
+            filename: value.name || key + '.csv',
+            csv: await value.text()
+          })
+      }
+      return { params, tables }
+    }
+
+    if (typeof body === 'string') {
+      try {
+        const parsed = JSON.parse(body)
+        return { params: {}, tables: [], json: parsed }
+      } catch (e) {
+        return { params: {}, tables: [] }
+      }
+    }
+    return { params, tables }
+  }
+
+  const safeParse = (text) => {
+    try {
+      return JSON.parse(text)
+    } catch (e) {
+      return text
+    }
+  }
+
+  const respond = (xhr, status, contentType, body) => {
+    Object.defineProperty(xhr, 'status', { value: status, configurable: true })
+    Object.defineProperty(xhr, 'statusText', {
+      value: status === 200 ? 'OK' : 'ERROR',
+      configurable: true
+    })
+    Object.defineProperty(xhr, 'readyState', { value: 4, configurable: true })
+    Object.defineProperty(xhr, 'responseText', {
+      value: body,
+      configurable: true
+    })
+    Object.defineProperty(xhr, 'responseURL', {
+      value: xhr.__sasjsMockUrl,
+      configurable: true
+    })
+    Object.defineProperty(xhr, 'response', {
+      value: xhr.responseType === 'json' ? safeParse(body) : body,
+      configurable: true
+    })
+    xhr.getAllResponseHeaders = () => 'content-type: ' + contentType + '\r\n'
+    xhr.getResponseHeader = (key) =>
+      key && key.toLowerCase() === 'content-type' ? contentType : null
+
+    xhr.dispatchEvent(new Event('readystatechange'))
+    xhr.dispatchEvent(new ProgressEvent('load'))
+    xhr.dispatchEvent(new ProgressEvent('loadend'))
+  }
+
+  const isSasjs = (url) =>
+    typeof url === 'string' && url.indexOf('/SASjsApi/') >= 0
+
+  const proto = XMLHttpRequest.prototype
+  const nativeOpen = proto.open
+  const nativeSend = proto.send
+
+  proto.open = function (method, url) {
+    this.__sasjsMockMethod = method
+    this.__sasjsMockUrl = String(url)
+    return nativeOpen.apply(this, arguments)
+  }
+
+  proto.send = function (body) {
+    if (!isSasjs(this.__sasjsMockUrl)) return nativeSend.apply(this, arguments)
+
+    const xhr = this
+    const method = (this.__sasjsMockMethod || 'GET').toUpperCase()
+
+    readBody(body)
+      .then(async (payload) => {
+        const init = {
+          method,
+          credentials: 'same-origin',
+          headers: { accept: '*/*' }
+        }
+        if (method !== 'GET' && method !== 'HEAD') {
+          init.headers['content-type'] = 'application/json'
+          init.body = JSON.stringify(payload)
+        }
+        dbg(
+          method,
+          xhr.__sasjsMockUrl,
+          payload.tables.map((t) => t.name).join('|')
+        )
+
+        const res = await fetch(xhr.__sasjsMockUrl, init)
+        const text = await res.text()
+        const contentType = res.headers.get('content-type') || 'text/plain'
+        if (res.status >= 400)
+          console.error(
+            '[sasjs-mock] ' +
+              xhr.__sasjsMockUrl +
+              ' -> ' +
+              res.status +
+              ' ' +
+              text.slice(0, 400)
+          )
+        respond(xhr, res.status, contentType, text)
+      })
+      .catch((err) => {
+        const message = String((err && err.message) || err)
+        console.error(
+          '[sasjs-mock] request failed: ' + xhr.__sasjsMockUrl + ' - ' + message
+        )
+        respond(
+          xhr,
+          500,
+          'application/json',
+          JSON.stringify({ message: message, error: message })
+        )
+      })
+  }
+
+  // fetch() is used by nothing in this build, but answering it keeps the
+  // bridge honest if a code path switches transport.
+  window.__sasjsMockHostStats = async () => {
+    const reg = await navigator.serviceWorker.ready
+    return {
+      active: !!reg.active,
+      controller: !!navigator.serviceWorker.controller
+    }
+  }
+})()

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

@@ -0,0 +1,75 @@
+// Compact MD5 (RFC 1321) returning lowercase hex. Used by the crypto shim so
+// that dcMockUtils' mp_hashdataset sees the same digests SAS produces.
+const MD5 = (() => {
+  const S = [
+    7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5,
+    9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11,
+    16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10,
+    15, 21
+  ]
+  const K = new Array(64)
+  for (let i = 0; i < 64; i++)
+    K[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296) | 0
+
+  const rotl = (x, c) => (x << c) | (x >>> (32 - c))
+
+  return function md5(input) {
+    const bytes = new TextEncoder().encode(String(input))
+    const bitLen = bytes.length * 8
+    const withPad = new Uint8Array((((bytes.length + 8) >> 6) + 1) * 64)
+    withPad.set(bytes)
+    withPad[bytes.length] = 0x80
+    const dv = new DataView(withPad.buffer)
+    dv.setUint32(withPad.length - 8, bitLen >>> 0, true)
+    dv.setUint32(withPad.length - 4, Math.floor(bitLen / 4294967296), true)
+
+    let a0 = 0x67452301,
+      b0 = 0xefcdab89,
+      c0 = 0x98badcfe,
+      d0 = 0x10325476
+
+    for (let off = 0; off < withPad.length; off += 64) {
+      const M = new Array(16)
+      for (let i = 0; i < 16; i++) M[i] = dv.getInt32(off + i * 4, true)
+      let A = a0,
+        B = b0,
+        C = c0,
+        D = d0
+      for (let i = 0; i < 64; i++) {
+        let F, g
+        if (i < 16) {
+          F = (B & C) | (~B & D)
+          g = i
+        } else if (i < 32) {
+          F = (D & B) | (~D & C)
+          g = (5 * i + 1) % 16
+        } else if (i < 48) {
+          F = B ^ C ^ D
+          g = (3 * i + 5) % 16
+        } else {
+          F = C ^ (B | ~D)
+          g = (7 * i) % 16
+        }
+        const tmp = D
+        D = C
+        C = B
+        B = (B + rotl((A + F + K[i] + M[g]) | 0, S[i])) | 0
+        A = tmp
+      }
+      a0 = (a0 + A) | 0
+      b0 = (b0 + B) | 0
+      c0 = (c0 + C) | 0
+      d0 = (d0 + D) | 0
+    }
+
+    const hex = (n) => {
+      let out = ''
+      for (let i = 0; i < 4; i++)
+        out += ((n >>> (i * 8)) & 0xff).toString(16).padStart(2, '0')
+      return out
+    }
+    return hex(a0) + hex(b0) + hex(c0) + hex(d0)
+  }
+})()
+
+if (typeof module !== 'undefined') module.exports = MD5

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

@@ -0,0 +1,222 @@
+/**
+ * Drive storage for the browser build: IndexedDB, owned by the page.
+ *
+ * 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.
+ */
+;(function () {
+  const DB_NAME = 'sasjs-mock-host'
+  const STORE = 'files'
+
+  const openDb = () =>
+    new Promise((resolve, reject) => {
+      const req = indexedDB.open(DB_NAME, 1)
+      req.onupgradeneeded = () => {
+        const db = req.result
+        if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE)
+      }
+      req.onsuccess = () => resolve(req.result)
+      req.onerror = () => reject(req.error)
+    })
+
+  const withStore = async (mode, run) => {
+    const db = await openDb()
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE, mode)
+      const store = tx.objectStore(STORE)
+      let result
+      try {
+        result = run(store)
+      } catch (e) {
+        reject(e)
+        return
+      }
+      tx.oncomplete = () => resolve(result)
+      tx.onerror = () => reject(tx.error)
+      tx.onabort = () => reject(tx.error)
+    })
+  }
+
+  const readAll = () =>
+    new Promise(async (resolve, reject) => {
+      try {
+        const db = await openDb()
+        const keysReq = db
+          .transaction(STORE, 'readonly')
+          .objectStore(STORE)
+          .getAllKeys()
+        keysReq.onsuccess = () => {
+          const keys = keysReq.result
+          if (!keys.length) return resolve({})
+          const valsReq = db
+            .transaction(STORE, 'readonly')
+            .objectStore(STORE)
+            .getAll()
+          valsReq.onsuccess = () => {
+            const files = {}
+            keys.forEach((k, i) => {
+              if (typeof valsReq.result[i] === 'string')
+                files[k] = valsReq.result[i]
+            })
+            resolve(files)
+          }
+          valsReq.onerror = () => reject(valsReq.error)
+        }
+        keysReq.onerror = () => reject(keysReq.error)
+      } catch (e) {
+        reject(e)
+      }
+    })
+
+  const writeFiles = async (files) => {
+    const entries = Object.entries(files || {})
+    if (!entries.length) return { written: 0, deleted: 0 }
+    let deleted = 0
+    await withStore('readwrite', (store) => {
+      for (const [path, contents] of entries) {
+        if (contents === null || contents === undefined) {
+          store.delete(path)
+          deleted++
+        } else {
+          store.put(contents, path)
+        }
+      }
+    })
+    return { written: entries.length - deleted, deleted }
+  }
+
+  const clearAll = () => withStore('readwrite', (store) => store.clear())
+
+  const waitForController = () =>
+    new Promise((resolve) => {
+      if (navigator.serviceWorker.controller)
+        return resolve(navigator.serviceWorker.controller)
+      let waited = 0
+      const tick = () => {
+        if (navigator.serviceWorker.controller)
+          return resolve(navigator.serviceWorker.controller)
+        if (waited > 10000) return resolve(null)
+        waited += 200
+        setTimeout(tick, 200)
+      }
+      tick()
+    })
+
+  const askWorker = (message, expect) =>
+    new Promise((resolve) => {
+      const sw = navigator.serviceWorker
+      let settled = false
+      let timer
+      const finish = (value) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        sw.removeEventListener('message', handler)
+        resolve(value)
+      }
+      const handler = (ev) => {
+        if (ev.data && ev.data.type === expect) finish(ev.data)
+      }
+      // The listener is removed on every path: a page that asks repeatedly with
+      // a slow worker would otherwise stack one listener per call, and a reply
+      // arriving after the timeout would land on a listener nobody reads.
+      timer = setTimeout(
+        () => finish({ error: 'timed out waiting for ' + expect }),
+        20000
+      )
+      sw.addEventListener('message', handler)
+      waitForController().then((controller) => {
+        if (!controller)
+          return finish({ error: 'no service worker controller' })
+        controller.postMessage(message)
+      })
+    })
+
+  // Persist whatever the worker reports as changed.
+  navigator.serviceWorker.addEventListener('message', (ev) => {
+    const data = ev.data || {}
+    if (data.type === 'sasjs-persist')
+      writeFiles(data.files).catch((e) =>
+        console.error('[sasjs-mock] persist failed', e)
+      )
+    if (data.type === 'sasjs-host-error')
+      console.error('[sasjs-mock] ' + data.path + ': ' + data.message)
+  })
+
+  window.SASjsMock = {
+    readAll,
+    writeFiles,
+    clear: clearAll,
+    snapshot: () => askWorker({ type: 'sasjs-snapshot' }, 'sasjs-snapshot'),
+    /**
+     * The drive total in bytes, measured by the worker: it owns the stored
+     * representation, so the figure stays the one `statSync` reports rather than
+     * the length of the strings this store happens to hold - which would count
+     * the base64 expansion and the marker of a byte entry.
+     */
+    stats: async () => {
+      const answer = await askWorker({ type: 'sasjs-stats' }, 'sasjs-stats')
+      // a worker that cannot report fails the read, as the other drive reads
+      // do: a caller destructuring { files, bytes } must not be handed NaN, and
+      // neither must a reply of an older shape that carries no stats at all
+      if (answer.error) throw new Error(answer.error)
+      if (!answer.stats) throw new Error('sasjs-stats reply carried no stats')
+      return answer.stats
+    },
+    /**
+     * Downloads the current drive as `mock-snapshot.json`. Drop that file in the
+     * build folder as `mock-snapshot.json` and the next build ships it, so every
+     * visitor starts from this state instead of from an empty drive.
+     */
+    download: async () => {
+      const snapshot = await askWorker(
+        { type: 'sasjs-snapshot' },
+        'sasjs-snapshot'
+      )
+      const files = (snapshot && snapshot.files) || {}
+      const blob = new Blob([JSON.stringify({ files }, null, 2)], {
+        type: 'application/json'
+      })
+      const url = URL.createObjectURL(blob)
+      const link = document.createElement('a')
+      link.href = url
+      link.download = 'mock-snapshot.json'
+      link.click()
+      setTimeout(() => URL.revokeObjectURL(url), 10000)
+      return Object.keys(files).length
+    },
+    reset: async () => {
+      await askWorker({ type: 'sasjs-reset' }, 'sasjs-reset-ack')
+      await clearAll()
+      return true
+    }
+  }
+
+  window.__sasjsMockReady = (async () => {
+    await navigator.serviceWorker.ready
+    const controller = await waitForController()
+    if (!controller) return { error: 'no service worker controller' }
+
+    let files = {}
+    try {
+      files = await readAll()
+    } catch (e) {
+      console.error('[sasjs-mock] could not read storage: ' + e)
+    }
+
+    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'
+      )
+    }
+    return window.__sasjsMockBoot
+  })()
+})()