@somewhere-tech/cli 0.10.0 → 0.12.0

package/runtime/sw-init.mjs

@@ -0,0 +1,237 @@
+// VENDORED from worker/src/utils/function-bundle.ts (SW_INIT_JS) @ 58927b3
+// — the exact runtime deployed functions run against. Do not edit by hand;
+// re-sync with: node scripts/extract-runtime.mjs <monorepo>
+// Generated by somewhere.tech deploy pipeline. Sets up the global
+// surfaces user modules need at module-load time.
+globalThis.sw = globalThis.sw || {};
+
+/** Parse "10/minute" / "60/hour" / "1000/day" into { max, windowSeconds }. */
+function __sw_parseRateLimit(spec) {
+  if (typeof spec !== 'string') return null;
+  var m = spec.match(/^\s*(\d+)\s*\/\s*(second|minute|hour|day)s?\s*$/i);
+  if (!m) return null;
+  var window = { second: 1, minute: 60, hour: 3600, day: 86400 }[m[2].toLowerCase()];
+  return { max: Number(m[1]), windowSeconds: window };
+}
+
+/** Best-effort client IP for rate-limit keying when no user is authed. */
+function __sw_clientIp(request) {
+  var h = request.headers;
+  return (
+    h.get('cf-connecting-ip') ||
+    h.get('x-forwarded-for')?.split(',')[0]?.trim() ||
+    h.get('x-real-ip') ||
+    'anon'
+  );
+}
+
+/**
+ * Validate `value` against a small declarative schema. Returns an
+ * array of error messages (empty if valid). Supports leaf strings as
+ * type names ('string', 'email', 'number', 'boolean', 'array',
+ * 'object'), trailing '?' for optional, and nested objects. Designed
+ * for body validation, not arbitrary JSON Schema.
+ */
+function __sw_validate(value, schema, path) {
+  path = path || '';
+  var errs = [];
+  if (typeof schema === 'string') {
+    var optional = schema.endsWith('?');
+    var type = optional ? schema.slice(0, -1) : schema;
+    if (value === undefined || value === null) {
+      if (!optional) errs.push(path + ': required');
+      return errs;
+    }
+    if (type === 'string' && typeof value !== 'string') errs.push(path + ': must be a string');
+    else if (type === 'email') {
+      if (typeof value !== 'string' || !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value)) errs.push(path + ': must be a valid email');
+    }
+    else if (type === 'number' && typeof value !== 'number') errs.push(path + ': must be a number');
+    else if (type === 'boolean' && typeof value !== 'boolean') errs.push(path + ': must be a boolean');
+    else if (type === 'array' && !Array.isArray(value)) errs.push(path + ': must be an array');
+    else if (type === 'object' && (typeof value !== 'object' || value === null || Array.isArray(value))) errs.push(path + ': must be an object');
+    return errs;
+  }
+  if (schema && typeof schema === 'object') {
+    if (value === null || value === undefined || typeof value !== 'object' || Array.isArray(value)) {
+      errs.push((path || 'body') + ': must be an object');
+      return errs;
+    }
+    for (var key of Object.keys(schema)) {
+      var sub = path ? path + '.' + key : key;
+      errs = errs.concat(__sw_validate(value[key], schema[key], sub));
+    }
+  }
+  return errs;
+}
+
+/** Build CORS headers off the config. 'same-origin' returns no
+ *  Access-Control-* — that's the default browsers enforce when no
+ *  header is present, exactly what we want. */
+function __sw_corsHeaders(corsCfg, request) {
+  if (!corsCfg || corsCfg === 'same-origin') return {};
+  var origin = request.headers.get('origin') || '';
+  var allowed;
+  if (corsCfg === '*') allowed = '*';
+  else if (Array.isArray(corsCfg)) {
+    var hit = corsCfg.find(function (o) {
+      return o === origin || origin.endsWith('.' + o);
+    });
+    if (!hit) return {};
+    allowed = origin;
+  } else {
+    return {};
+  }
+  return {
+    'Access-Control-Allow-Origin': allowed,
+    'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    'Vary': 'Origin',
+  };
+}
+
+function __sw_jsonError(status, code, message, extras) {
+  var body = Object.assign({ ok: false, error: code, message: message }, extras || {});
+  return new Response(JSON.stringify(body), {
+    status: status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+function __sw_mergeHeaders(response, extra) {
+  if (!extra || Object.keys(extra).length === 0) return response;
+  var headers = new Headers(response.headers);
+  for (var k of Object.keys(extra)) headers.set(k, extra[k]);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: headers,
+  });
+}
+
+/**
+ * sw.endpoint({ auth, body, rateLimit, cors, handler }) → handler.
+ *
+ * Returns an async (request, sw) => Response | object that the shim
+ * dispatches to like any other default-export handler. Pipeline:
+ *
+ *   1. CORS preflight — answer OPTIONS with 204 + allow headers.
+ *   2. Auth — required throws 401, optional enriches user when present.
+ *   3. Body validation — parses JSON, validates against schema.
+ *   4. Rate limit — per-(user|ip)-per-path counter via sw.rateLimit.
+ *   5. Handler — { body, user, headers, params, request } + sw.
+ *   6. Error wrap — clean JSON { ok:false, error, message }.
+ *   7. CORS — append Access-Control-* to the response.
+ */
+globalThis.sw.endpoint = function (config) {
+  config = config || {};
+  if (typeof config.handler !== 'function') {
+    throw new Error('sw.endpoint: handler is required (an async function).');
+  }
+  var auth = config.auth || 'none';
+  var bodySchema = config.body || null;
+  var rateLimit = __sw_parseRateLimit(config.rateLimit);
+  var cors = config.cors || 'same-origin';
+
+  return async function endpointHandler(request, sw) {
+    var corsHeaders = __sw_corsHeaders(cors, request);
+    if (request.method === 'OPTIONS') {
+      return new Response(null, { status: 204, headers: corsHeaders });
+    }
+
+    // Auth.
+    var user = null;
+    if (auth === 'required') {
+      try {
+        user = await sw.auth.requireUser(request);
+      } catch (e) {
+        return __sw_mergeHeaders(
+          __sw_jsonError(e.status || 401, e.code || 'AUTH_REQUIRED', e.message || 'Sign in required.'),
+          corsHeaders
+        );
+      }
+    } else if (auth === 'optional') {
+      try { user = await sw.auth.fromRequest(request); } catch (_) { /* swallow */ }
+    }
+
+    // Body validation (skipped on GET/DELETE/HEAD — no body expected).
+    var body = null;
+    if (bodySchema && request.method !== 'GET' && request.method !== 'DELETE' && request.method !== 'HEAD') {
+      try { body = await request.json(); }
+      catch (_) {
+        return __sw_mergeHeaders(
+          __sw_jsonError(400, 'INVALID_JSON', 'Request body must be valid JSON.'),
+          corsHeaders
+        );
+      }
+      var errors = __sw_validate(body, bodySchema, '');
+      if (errors.length) {
+        return __sw_mergeHeaders(
+          __sw_jsonError(400, 'VALIDATION_ERROR', errors.join('; '), { fields: errors }),
+          corsHeaders
+        );
+      }
+    }
+
+    // Rate limit. Key by user id when authed (sticky across IPs);
+    // by client IP otherwise. Path is included so two endpoints don't
+    // share a bucket.
+    if (rateLimit) {
+      var pathname = '';
+      try { pathname = new URL(request.url).pathname; } catch (_) {}
+      var rlKey = 'endpoint:' + (user?.id || __sw_clientIp(request)) + ':' + pathname;
+      try {
+        var r = await sw.rateLimit.check(rlKey, rateLimit.max, rateLimit.windowSeconds);
+        if (!r || r.allowed === false) {
+          var retry = (r && r.reset) || rateLimit.windowSeconds;
+          return __sw_mergeHeaders(
+            new Response(
+              JSON.stringify({ ok: false, error: 'RATE_LIMITED', message: 'Too many requests.', retry_after: retry }),
+              { status: 429, headers: { 'Content-Type': 'application/json', 'Retry-After': String(retry) } }
+            ),
+            corsHeaders
+          );
+        }
+      } catch (_) {
+        // fail-loudly + fail-CLOSED (tsk_9f22): if the rate-limit check
+        // itself errors we used to let the request through — silently
+        // disabling the limiter. Block instead. A rate-limited endpoint
+        // must never serve unthrottled just because the limiter hiccuped.
+        return __sw_mergeHeaders(
+          new Response(
+            JSON.stringify({ ok: false, error: 'RATE_LIMIT_UNAVAILABLE', message: 'Rate limiting is temporarily unavailable; this request was blocked. Retry shortly.' }),
+            { status: 503, headers: { 'Content-Type': 'application/json', 'Retry-After': String(rateLimit.windowSeconds) } }
+          ),
+          corsHeaders
+        );
+      }
+    }
+
+    // Handler. Catches any throw, surfacing { status, code } when
+    // present so handler code can throw rich errors without manual
+    // Response building.
+    try {
+      var result = await config.handler(
+        { body: body, user: user, headers: request.headers, params: request.params || {}, request: request },
+        sw
+      );
+      var response;
+      if (result instanceof Response) {
+        response = result;
+      } else if (result === undefined || result === null) {
+        response = new Response(null, { status: 204 });
+      } else {
+        response = new Response(JSON.stringify(result), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      return __sw_mergeHeaders(response, corsHeaders);
+    } catch (e) {
+      return __sw_mergeHeaders(
+        __sw_jsonError(e.status || 500, e.code || 'HANDLER_ERROR', e.message || String(e)),
+        corsHeaders
+      );
+    }
+  };
+};