@pulse-compute/provider-fastly 0.0.0 → 1.0.0-beta.10

package/src/javascript/package-effects.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { fastlyJavascriptProviderError } = require('./errors.js');
+
+const FASTLY_JAVASCRIPT_PACKAGE_EFFECTS_VERSION = 'pulse.fastly-javascript-package-effects.v1';
+
+function unavailable(effect = {}) {
+  throw fastlyJavascriptProviderError(
+    'PULSE_RUNTIME_CAPABILITY_UNAVAILABLE',
+    `Pulse capability ${effect.capability || effect.kind || 'package-effect'} is unavailable in the Fastly JavaScript realization.`,
+    { package: effect.package, contractId: effect.contractId, operation: effect.operation }
+  );
+}
+
+function createFastlyJavascriptPackageEffectCapabilities(options = {}) {
+  const assetsLookup = options.assetsLookup;
+  const gripBroadcast = options.gripBroadcast;
+  const digestText = require('@pulse-compute/crypto/provider').createJavascriptTextDigest(options);
+  const jwtVerify = options.jwtVerify;
+  return Object.freeze({
+    version: FASTLY_JAVASCRIPT_PACKAGE_EFFECTS_VERSION,
+    effect(effect, execution) {
+      if (effect && effect.contractId === 'pulse.crypto' && effect.operation === 'digestText') return digestText(effect, execution);
+      if (effect && effect.contractId === 'pulse.assets' && effect.operation === 'lookup') {
+        if (typeof assetsLookup !== 'function') return unavailable(effect);
+        return assetsLookup(effect.payload, execution);
+      }
+      if (effect && effect.contractId === 'pulse.grip' && effect.operation === 'broadcast') {
+        if (typeof gripBroadcast !== 'function') {
+          throw fastlyJavascriptProviderError(
+            'PULSE_GRIP_BROADCAST_CAPABILITY_REQUIRED',
+            'GRIP broadcast requires a configured Fastly publish capability.',
+            { package: effect.package, operation: 'broadcast', configuration: 'bindings.grip.publishEndpoint' }
+          );
+        }
+        return gripBroadcast(effect.payload, execution);
+      }
+      if (effect && effect.contractId === 'pulse.jwt' && ['verify', 'sign'].includes(effect.operation)) {
+        if (typeof jwtVerify !== 'function') return unavailable(effect);
+        return jwtVerify(effect, execution);
+      }
+      return unavailable(effect);
+    }
+  });
+}
+
+function withFastlyPackageEffectCapabilities(capabilities, options = {}) {
+  const base = capabilities && typeof capabilities === 'object' ? capabilities : {};
+  const configured = createFastlyJavascriptPackageEffectCapabilities(options);
+  return Object.freeze({
+    ...base,
+    effect(effect, execution) {
+      if (effect && (
+        effect.contractId === 'pulse.crypto'
+        || effect.contractId === 'pulse.assets'
+        || effect.contractId === 'pulse.grip'
+        || effect.contractId === 'pulse.jwt'
+      )) {
+        return configured.effect(effect, execution);
+      }
+      if (typeof base.effect === 'function') return base.effect(effect, execution);
+      return unavailable(effect);
+    }
+  });
+}
+
+module.exports = Object.freeze({
+  FASTLY_JAVASCRIPT_PACKAGE_EFFECTS_VERSION,
+  createFastlyJavascriptPackageEffectCapabilities,
+  withFastlyPackageEffectCapabilities
+});

package/src/javascript/runtime-host.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const runtimeHost = require('@pulse-compute/runtime/host');
+const {
+  createFastlyJavascriptBindingCapabilities,
+  withFastlyBindingCapabilities
+} = require('./bindings-adapter.js');
+const { createFastlyJavascriptFetchCapability, withFastlyFetchCapability } = require('./fetch-adapter.js');
+const { createFastlyJavascriptAssetsLookup } = require('./assets-adapter.js');
+const { createFastlyJavascriptGripBroadcast } = require('./grip-broadcast.js');
+const { createFastlyJavascriptJwtVerify } = require('./jwt-verifier.js');
+const { withFastlyPackageEffectCapabilities } = require('./package-effects.js');
+const { createFastlyJavascriptLogEmitter } = require('./logging.js');
+
+const FASTLY_JAVASCRIPT_RUNTIME_HOST_VERSION = 'pulse.fastly-javascript-runtime-host.v1';
+
+function isFastlyJavascriptApplication(value) {
+  return runtimeHost.isRouterApplication(value) || typeof value === 'function';
+}
+
+function assertFastlyJavascriptApplication(value) {
+  return runtimeHost.normalizeApplication(value);
+}
+
+function createFastlyJavascriptCapabilities(options = {}) {
+  const bindingCapabilities = createFastlyJavascriptBindingCapabilities(options);
+  const assetsLookup = createFastlyJavascriptAssetsLookup(options);
+  const jwtVerify = createFastlyJavascriptJwtVerify({
+    captureWallClock: options.jwtCaptureWallClock,
+    secretLookup: bindingCapabilities.secret
+  });
+  const grip = options.bindings && options.bindings.grip;
+  let configuredGripBroadcast;
+  const gripBroadcast = grip && (grip.publishEndpoint || grip.publishUrl)
+    ? (payload, execution) => {
+        if (!configuredGripBroadcast) {
+          configuredGripBroadcast = createFastlyJavascriptGripBroadcast({
+            ...options,
+            grip,
+            secretLookup: bindingCapabilities.secret
+          });
+        }
+        return configuredGripBroadcast(payload, execution);
+      }
+    : undefined;
+  return withFastlyPackageEffectCapabilities(
+    withFastlyFetchCapability(
+      withFastlyBindingCapabilities({ time: () => runtimeHost.readWallTime(options.wallClock === undefined ? () => Date.now() : options.wallClock), ...options.capabilities }, { ...options, bindingCapabilities }),
+      { ...options, fetchImplementation: options.fetchImplementation }
+    ),
+    { assetsLookup, gripBroadcast, jwtVerify, digestSubtle: options.digestSubtle }
+  );
+}
+
+function requestHeaderPairs(request) {
+  return Object.freeze(Array.from(request.headers.entries(), ([name, value]) => Object.freeze([name, value])));
+}
+
+async function executeFastlyJavascriptApplication(application, request, options = {}) {
+  if (options.maxDurationMs !== undefined || options.requestBudget !== undefined) {
+    throw new runtimeHost.PulseRuntimeContractError('PULSE_REQUEST_DURATION_UNSUPPORTED', 'Fastly JavaScript does not implement the request deadline; select Native.');
+  }
+  const capabilities = options.effectAdapter === undefined
+    ? createFastlyJavascriptCapabilities(options)
+    : undefined;
+  return runtimeHost.executeApplication(assertFastlyJavascriptApplication(application), request, {
+    capabilities,
+    effectAdapter: options.effectAdapter,
+    application: options.application,
+    requestHeaders: options.requestHeaders || requestHeaderPairs(request),
+    signal: options.signal || request.signal,
+    maxEffects: options.maxEffects,
+    maxRequestBodyBytes: options.maxRequestBodyBytes,
+    maxFetchBodyBytes: options.maxFetchBodyBytes,
+    maxStructuredBodyBytes: options.maxStructuredBodyBytes,
+    maxBindingNameBytes: options.maxBindingNameBytes,
+    maxBindingValueBytes: options.maxBindingValueBytes,
+    maxKvNamespaceBytes: options.maxKvNamespaceBytes,
+    maxKvKeyBytes: options.maxKvKeyBytes,
+    maxKvValueBytes: options.maxKvValueBytes,
+    maxKvValueDepth: options.maxKvValueDepth,
+    maxKvValueEntries: options.maxKvValueEntries,
+    binaryResources: options.binaryResources,
+    schemaCodecs: options.schemaCodecs,
+    strict: options.strict === true,
+    target: 'javascript',
+    provider: 'fastly',
+    reporting: options.reporting,
+    log: options.log || createFastlyJavascriptLogEmitter({ console: options.console, logEndpoint: options.bindings?.logEndpoint, Logger: options.apis?.Logger }),
+    redactionValues: options.redactionValues,
+    onLogObservation: options.onLogObservation,
+    onJsonTrace: options.onJsonTrace,
+    onEffectObservation: options.onEffectObservation,
+    onEffectSummary: options.onEffectSummary
+  });
+}
+
+module.exports = Object.freeze({
+  FASTLY_JAVASCRIPT_RUNTIME_HOST_VERSION,
+  PulseRuntimeContractError: runtimeHost.PulseRuntimeContractError,
+  createFastlyJavascriptAssetsLookup,
+  createFastlyJavascriptBindingCapabilities,
+  createFastlyJavascriptCapabilities,
+  createFastlyJavascriptFetchCapability,
+  createFastlyJavascriptGripBroadcast,
+  createFastlyJavascriptJwtVerify,
+  createFastlyJavascriptLogEmitter,
+  assertFastlyJavascriptApplication,
+  executeFastlyJavascriptApplication,
+  isFastlyJavascriptApplication,
+  requestHeaderPairs
+});

package/src/javascript/sha256.js

@@ -0,0 +1,128 @@
+'use strict';
+
+// A small synchronous SHA-256 bridge used only by generated schema semantic
+// traces. Fastly exposes Web Crypto asynchronously, while the shared trace
+// contract intentionally computes deterministic digests synchronously.
+const K = Object.freeze([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+
+function rotateRight(value, amount) {
+  return (value >>> amount) | (value << (32 - amount));
+}
+
+function inputBytes(value) {
+  if (typeof value === 'string') return new TextEncoder().encode(value);
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  return new TextEncoder().encode(String(value));
+}
+
+function sha256Bytes(input) {
+  const bytes = inputBytes(input);
+  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+  const message = new Uint8Array(paddedLength);
+  message.set(bytes);
+  message[bytes.byteLength] = 0x80;
+  const bitLength = BigInt(bytes.byteLength) * 8n;
+  for (let index = 0; index < 8; index += 1) {
+    message[paddedLength - 1 - index] = Number((bitLength >> BigInt(index * 8)) & 0xffn);
+  }
+
+  const state = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+  ]);
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < message.byteLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const position = offset + index * 4;
+      words[index] = (
+        (message[position] << 24)
+        | (message[position + 1] << 16)
+        | (message[position + 2] << 8)
+        | message[position + 3]
+      ) >>> 0;
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const left = words[index - 15];
+      const right = words[index - 2];
+      const s0 = rotateRight(left, 7) ^ rotateRight(left, 18) ^ (left >>> 3);
+      const s1 = rotateRight(right, 17) ^ rotateRight(right, 19) ^ (right >>> 10);
+      words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+    }
+
+    let [a, b, c, d, e, f, g, h] = state;
+    for (let index = 0; index < 64; index += 1) {
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = (e & f) ^ (~e & g);
+      const temporary1 = (h + sum1 + choice + K[index] + words[index]) >>> 0;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = (a & b) ^ (a & c) ^ (b & c);
+      const temporary2 = (sum0 + majority) >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d + temporary1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (temporary1 + temporary2) >>> 0;
+    }
+    state[0] = (state[0] + a) >>> 0;
+    state[1] = (state[1] + b) >>> 0;
+    state[2] = (state[2] + c) >>> 0;
+    state[3] = (state[3] + d) >>> 0;
+    state[4] = (state[4] + e) >>> 0;
+    state[5] = (state[5] + f) >>> 0;
+    state[6] = (state[6] + g) >>> 0;
+    state[7] = (state[7] + h) >>> 0;
+  }
+
+  const digest = new Uint8Array(32);
+  for (let index = 0; index < state.length; index += 1) {
+    digest[index * 4] = state[index] >>> 24;
+    digest[index * 4 + 1] = state[index] >>> 16;
+    digest[index * 4 + 2] = state[index] >>> 8;
+    digest[index * 4 + 3] = state[index];
+  }
+  return digest;
+}
+
+function createHash(algorithm) {
+  if (String(algorithm).toLowerCase().replace('-', '') !== 'sha256') {
+    throw new TypeError('Pulse Fastly JavaScript supports SHA-256 digests only.');
+  }
+  const chunks = [];
+  return {
+    update(value) {
+      chunks.push(inputBytes(value));
+      return this;
+    },
+    digest(encoding) {
+      const length = chunks.reduce((sum, entry) => sum + entry.byteLength, 0);
+      const input = new Uint8Array(length);
+      let offset = 0;
+      for (const chunk of chunks) {
+        input.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      const output = sha256Bytes(input);
+      if (encoding === undefined) return output;
+      if (String(encoding).toLowerCase() !== 'hex') {
+        throw new TypeError('Pulse Fastly JavaScript SHA-256 bridge supports hex output only.');
+      }
+      return Array.from(output, (byte) => byte.toString(16).padStart(2, '0')).join('');
+    }
+  };
+}
+
+module.exports = Object.freeze({ createHash, sha256Bytes });