@golocalinteractive/golocal-cloud-wrapper 1.0.54 → 1.0.56

package/dist/golocal-cloud-wrapper.es145.js

@@ -0,0 +1,301 @@
+function stringifyCookie(c) {
+  var _a;
+  const attrs = [
+    "path" in c && c.path && `Path=${c.path}`,
+    "expires" in c && (c.expires || c.expires === 0) && `Expires=${(typeof c.expires === "number" ? new Date(c.expires) : c.expires).toUTCString()}`,
+    "maxAge" in c && typeof c.maxAge === "number" && `Max-Age=${c.maxAge}`,
+    "domain" in c && c.domain && `Domain=${c.domain}`,
+    "secure" in c && c.secure && "Secure",
+    "httpOnly" in c && c.httpOnly && "HttpOnly",
+    "sameSite" in c && c.sameSite && `SameSite=${c.sameSite}`,
+    "partitioned" in c && c.partitioned && "Partitioned",
+    "priority" in c && c.priority && `Priority=${c.priority}`
+  ].filter(Boolean);
+  const stringified = `${c.name}=${encodeURIComponent((_a = c.value) != null ? _a : "")}`;
+  return attrs.length === 0 ? stringified : `${stringified}; ${attrs.join("; ")}`;
+}
+function parseCookie(cookie) {
+  const map = /* @__PURE__ */ new Map();
+  for (const pair of cookie.split(/; */)) {
+    if (!pair)
+      continue;
+    const splitAt = pair.indexOf("=");
+    if (splitAt === -1) {
+      map.set(pair, "true");
+      continue;
+    }
+    const [key, value] = [pair.slice(0, splitAt), pair.slice(splitAt + 1)];
+    try {
+      map.set(key, decodeURIComponent(value != null ? value : "true"));
+    } catch {
+    }
+  }
+  return map;
+}
+function parseSetCookie(setCookie) {
+  if (!setCookie) {
+    return void 0;
+  }
+  const [[name, value], ...attributes] = parseCookie(setCookie);
+  const {
+    domain,
+    expires,
+    httponly,
+    maxage,
+    path,
+    samesite,
+    secure,
+    partitioned,
+    priority
+  } = Object.fromEntries(
+    attributes.map(([key, value2]) => [
+      key.toLowerCase().replace(/-/g, ""),
+      value2
+    ])
+  );
+  const cookie = {
+    name,
+    value: decodeURIComponent(value),
+    domain,
+    ...expires && { expires: new Date(expires) },
+    ...httponly && { httpOnly: true },
+    ...typeof maxage === "string" && { maxAge: Number(maxage) },
+    path,
+    ...samesite && { sameSite: parseSameSite(samesite) },
+    ...secure && { secure: true },
+    ...priority && { priority: parsePriority(priority) },
+    ...partitioned && { partitioned: true }
+  };
+  return compact(cookie);
+}
+function compact(t) {
+  const newT = {};
+  for (const key in t) {
+    if (t[key]) {
+      newT[key] = t[key];
+    }
+  }
+  return newT;
+}
+var SAME_SITE = ["strict", "lax", "none"];
+function parseSameSite(string) {
+  string = string.toLowerCase();
+  return SAME_SITE.includes(string) ? string : void 0;
+}
+var PRIORITY = ["low", "medium", "high"];
+function parsePriority(string) {
+  string = string.toLowerCase();
+  return PRIORITY.includes(string) ? string : void 0;
+}
+function splitCookiesString(cookiesString) {
+  if (!cookiesString)
+    return [];
+  var cookiesStrings = [];
+  var pos = 0;
+  var start;
+  var ch;
+  var lastComma;
+  var nextStart;
+  var cookiesSeparatorFound;
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+var RequestCookies = class {
+  constructor(requestHeaders) {
+    this._parsed = /* @__PURE__ */ new Map();
+    this._headers = requestHeaders;
+    const header = requestHeaders.get("cookie");
+    if (header) {
+      const parsed = parseCookie(header);
+      for (const [name, value] of parsed) {
+        this._parsed.set(name, { name, value });
+      }
+    }
+  }
+  [Symbol.iterator]() {
+    return this._parsed[Symbol.iterator]();
+  }
+  /**
+   * The amount of cookies received from the client
+   */
+  get size() {
+    return this._parsed.size;
+  }
+  get(...args) {
+    const name = typeof args[0] === "string" ? args[0] : args[0].name;
+    return this._parsed.get(name);
+  }
+  getAll(...args) {
+    var _a;
+    const all = Array.from(this._parsed);
+    if (!args.length) {
+      return all.map(([_, value]) => value);
+    }
+    const name = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+    return all.filter(([n]) => n === name).map(([_, value]) => value);
+  }
+  has(name) {
+    return this._parsed.has(name);
+  }
+  set(...args) {
+    const [name, value] = args.length === 1 ? [args[0].name, args[0].value] : args;
+    const map = this._parsed;
+    map.set(name, { name, value });
+    this._headers.set(
+      "cookie",
+      Array.from(map).map(([_, value2]) => stringifyCookie(value2)).join("; ")
+    );
+    return this;
+  }
+  /**
+   * Delete the cookies matching the passed name or names in the request.
+   */
+  delete(names) {
+    const map = this._parsed;
+    const result = !Array.isArray(names) ? map.delete(names) : names.map((name) => map.delete(name));
+    this._headers.set(
+      "cookie",
+      Array.from(map).map(([_, value]) => stringifyCookie(value)).join("; ")
+    );
+    return result;
+  }
+  /**
+   * Delete all the cookies in the cookies in the request.
+   */
+  clear() {
+    this.delete(Array.from(this._parsed.keys()));
+    return this;
+  }
+  /**
+   * Format the cookies in the request as a string for logging
+   */
+  [Symbol.for("edge-runtime.inspect.custom")]() {
+    return `RequestCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+  }
+  toString() {
+    return [...this._parsed.values()].map((v) => `${v.name}=${encodeURIComponent(v.value)}`).join("; ");
+  }
+};
+var ResponseCookies = class {
+  constructor(responseHeaders) {
+    this._parsed = /* @__PURE__ */ new Map();
+    var _a, _b, _c;
+    this._headers = responseHeaders;
+    const setCookie = (_c = (_b = (_a = responseHeaders.getSetCookie) == null ? void 0 : _a.call(responseHeaders)) != null ? _b : responseHeaders.get("set-cookie")) != null ? _c : [];
+    const cookieStrings = Array.isArray(setCookie) ? setCookie : splitCookiesString(setCookie);
+    for (const cookieString of cookieStrings) {
+      const parsed = parseSetCookie(cookieString);
+      if (parsed)
+        this._parsed.set(parsed.name, parsed);
+    }
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+   */
+  get(...args) {
+    const key = typeof args[0] === "string" ? args[0] : args[0].name;
+    return this._parsed.get(key);
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+   */
+  getAll(...args) {
+    var _a;
+    const all = Array.from(this._parsed.values());
+    if (!args.length) {
+      return all;
+    }
+    const key = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+    return all.filter((c) => c.name === key);
+  }
+  has(name) {
+    return this._parsed.has(name);
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+   */
+  set(...args) {
+    const [name, value, cookie] = args.length === 1 ? [args[0].name, args[0].value, args[0]] : args;
+    const map = this._parsed;
+    map.set(name, normalizeCookie({ name, value, ...cookie }));
+    replace(map, this._headers);
+    return this;
+  }
+  /**
+   * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+   */
+  delete(...args) {
+    const [name, options] = typeof args[0] === "string" ? [args[0]] : [args[0].name, args[0]];
+    return this.set({ ...options, name, value: "", expires: /* @__PURE__ */ new Date(0) });
+  }
+  [Symbol.for("edge-runtime.inspect.custom")]() {
+    return `ResponseCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+  }
+  toString() {
+    return [...this._parsed.values()].map(stringifyCookie).join("; ");
+  }
+};
+function replace(bag, headers) {
+  headers.delete("set-cookie");
+  for (const [, value] of bag) {
+    const serialized = stringifyCookie(value);
+    headers.append("set-cookie", serialized);
+  }
+}
+function normalizeCookie(cookie = { name: "", value: "" }) {
+  if (typeof cookie.expires === "number") {
+    cookie.expires = new Date(cookie.expires);
+  }
+  if (cookie.maxAge) {
+    cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
+  }
+  if (cookie.path === null || cookie.path === void 0) {
+    cookie.path = "/";
+  }
+  return cookie;
+}
+export {
+  RequestCookies,
+  ResponseCookies,
+  parseCookie,
+  parseSetCookie,
+  stringifyCookie
+};

package/dist/golocal-cloud-wrapper.es146.js

@@ -0,0 +1,90 @@
+import { decrypt, verifySigned, encrypt } from "./golocal-cloud-wrapper.es152.js";
+import { AbstractSessionStore } from "./golocal-cloud-wrapper.es157.js";
+import { LEGACY_COOKIE_NAME, normalizeStatefulSession } from "./golocal-cloud-wrapper.es204.js";
+const generateId = () => {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+class StatefulSessionStore extends AbstractSessionStore {
+  constructor({ secret, store, rolling, absoluteDuration, inactivityDuration, cookieOptions }) {
+    super({
+      secret,
+      rolling,
+      absoluteDuration,
+      inactivityDuration,
+      cookieOptions
+    });
+    this.store = store;
+  }
+  async get(reqCookies) {
+    const cookie = reqCookies.get(this.sessionCookieName) || reqCookies.get(LEGACY_COOKIE_NAME);
+    if (!cookie || !cookie.value) {
+      return null;
+    }
+    let sessionId = null;
+    try {
+      const { payload: sessionCookie } = await decrypt(cookie.value, this.secret);
+      sessionId = sessionCookie.id;
+    } catch (e) {
+      if (e.code === "ERR_JWE_INVALID") {
+        const legacySessionId = await verifySigned(cookie.name, cookie.value, this.secret);
+        if (!legacySessionId) {
+          return null;
+        }
+        sessionId = legacySessionId;
+      }
+    }
+    if (!sessionId) {
+      return null;
+    }
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return null;
+    }
+    return normalizeStatefulSession(session);
+  }
+  async set(reqCookies, resCookies, session, isNew = false) {
+    var _a;
+    let sessionId = null;
+    const cookieValue = (_a = reqCookies.get(this.sessionCookieName)) == null ? void 0 : _a.value;
+    if (cookieValue) {
+      const { payload: sessionCookie } = await decrypt(cookieValue, this.secret);
+      sessionId = sessionCookie.id;
+    }
+    if (sessionId && isNew) {
+      await this.store.delete(sessionId);
+      sessionId = generateId();
+    }
+    if (!sessionId) {
+      sessionId = generateId();
+    }
+    const maxAge = this.calculateMaxAge(session.internal.createdAt);
+    const expiration = Date.now() / 1e3 + maxAge;
+    const jwe = await encrypt({
+      id: sessionId
+    }, this.secret, expiration);
+    resCookies.set(this.sessionCookieName, jwe.toString(), {
+      ...this.cookieConfig,
+      maxAge
+    });
+    await this.store.set(sessionId, session);
+    reqCookies.set(this.sessionCookieName, jwe.toString());
+    if (this.sessionCookieName !== LEGACY_COOKIE_NAME && reqCookies.has(LEGACY_COOKIE_NAME)) {
+      resCookies.delete(LEGACY_COOKIE_NAME);
+    }
+  }
+  async delete(reqCookies, resCookies) {
+    var _a;
+    const cookieValue = (_a = reqCookies.get(this.sessionCookieName)) == null ? void 0 : _a.value;
+    await resCookies.delete(this.sessionCookieName);
+    if (!cookieValue) {
+      return;
+    }
+    const { payload: session } = await decrypt(cookieValue, this.secret);
+    await this.store.delete(session.id);
+  }
+}
+export {
+  StatefulSessionStore
+};

package/dist/golocal-cloud-wrapper.es147.js

@@ -0,0 +1,83 @@
+import { getChunkedCookie, decrypt, encrypt, setChunkedCookie, deleteChunkedCookie } from "./golocal-cloud-wrapper.es152.js";
+import { AbstractSessionStore } from "./golocal-cloud-wrapper.es157.js";
+import { normalizeStatelessSession, LEGACY_COOKIE_NAME } from "./golocal-cloud-wrapper.es204.js";
+import { ResponseCookies } from "./golocal-cloud-wrapper.es145.js";
+class StatelessSessionStore extends AbstractSessionStore {
+  constructor({ secret, rolling, absoluteDuration, inactivityDuration, cookieOptions }) {
+    super({
+      secret,
+      rolling,
+      absoluteDuration,
+      inactivityDuration,
+      cookieOptions
+    });
+    this.connectionTokenSetsCookieName = "__FC";
+  }
+  async get(reqCookies) {
+    const cookieValue = getChunkedCookie(this.sessionCookieName, reqCookies) ?? getChunkedCookie(LEGACY_COOKIE_NAME, reqCookies, true);
+    if (!cookieValue) {
+      return null;
+    }
+    const originalSession = await decrypt(cookieValue, this.secret);
+    const normalizedStatelessSession = normalizeStatelessSession(originalSession);
+    const connectionTokenSets = await Promise.all(this.getConnectionTokenSetsCookies(reqCookies).map((cookie) => decrypt(cookie.value, this.secret)));
+    return {
+      ...normalizedStatelessSession,
+      // Ensure that when there are no connection token sets, we omit the property.
+      ...connectionTokenSets.length ? {
+        connectionTokenSets: connectionTokenSets.map((tokenSet) => tokenSet.payload)
+      } : {}
+    };
+  }
+  /**
+   * save adds the encrypted session cookie as a `Set-Cookie` header.
+   */
+  async set(reqCookies, resCookies, session) {
+    const { connectionTokenSets, ...originalSession } = session;
+    const maxAge = this.calculateMaxAge(session.internal.createdAt);
+    const expiration = Math.floor(Date.now() / 1e3) + maxAge;
+    const jwe = await encrypt(originalSession, this.secret, expiration);
+    const cookieValue = jwe.toString();
+    const options = {
+      ...this.cookieConfig,
+      maxAge
+    };
+    setChunkedCookie(this.sessionCookieName, cookieValue, options, reqCookies, resCookies);
+    if (connectionTokenSets == null ? void 0 : connectionTokenSets.length) {
+      await Promise.all(connectionTokenSets.map((connectionTokenSet, index) => this.storeInCookie(reqCookies, resCookies, connectionTokenSet, `${this.connectionTokenSetsCookieName}_${index}`, maxAge)));
+    }
+    deleteChunkedCookie(LEGACY_COOKIE_NAME, reqCookies, resCookies, true);
+  }
+  async delete(reqCookies, resCookies) {
+    deleteChunkedCookie(this.sessionCookieName, reqCookies, resCookies);
+    this.getConnectionTokenSetsCookies(reqCookies).forEach((cookie) => resCookies.delete(cookie.name));
+  }
+  async storeInCookie(reqCookies, resCookies, session, cookieName, maxAge) {
+    const expiration = Math.floor(Date.now() / 1e3 + maxAge);
+    const jwe = await encrypt(session, this.secret, expiration);
+    const cookieValue = jwe.toString();
+    resCookies.set(cookieName, jwe.toString(), {
+      ...this.cookieConfig,
+      maxAge
+    });
+    reqCookies.set(cookieName, cookieValue);
+    const cookieJarSizeTest = new ResponseCookies(new Headers());
+    cookieJarSizeTest.set(cookieName, cookieValue, {
+      ...this.cookieConfig,
+      maxAge
+    });
+    if (new TextEncoder().encode(cookieJarSizeTest.toString()).length >= 4096) {
+      if (cookieName === this.sessionCookieName) {
+        console.warn(`The ${cookieName} cookie size exceeds 4096 bytes, which may cause issues in some browsers. Consider removing any unnecessary custom claims from the access token or the user profile. Alternatively, you can use a stateful session implementation to store the session data in a data store.`);
+      } else {
+        console.warn(`The ${cookieName} cookie size exceeds 4096 bytes, which may cause issues in some browsers. You can use a stateful session implementation to store the session data in a data store.`);
+      }
+    }
+  }
+  getConnectionTokenSetsCookies(cookies) {
+    return cookies.getAll().filter((cookie) => cookie.name.startsWith(this.connectionTokenSetsCookieName));
+  }
+}
+export {
+  StatelessSessionStore
+};

package/dist/golocal-cloud-wrapper.es148.js

@@ -0,0 +1,65 @@
+import { encrypt, decrypt } from "./golocal-cloud-wrapper.es152.js";
+const TRANSACTION_COOKIE_PREFIX = "__txn_";
+class TransactionStore {
+  constructor({ secret, cookieOptions }) {
+    this.secret = secret;
+    this.transactionCookiePrefix = (cookieOptions == null ? void 0 : cookieOptions.prefix) ?? TRANSACTION_COOKIE_PREFIX;
+    this.cookieConfig = {
+      httpOnly: true,
+      sameSite: (cookieOptions == null ? void 0 : cookieOptions.sameSite) ?? "lax",
+      // required to allow the cookie to be sent on the callback request
+      secure: (cookieOptions == null ? void 0 : cookieOptions.secure) ?? false,
+      path: (cookieOptions == null ? void 0 : cookieOptions.path) ?? "/",
+      maxAge: 60 * 60
+      // 1 hour in seconds
+    };
+  }
+  /**
+   * Returns the name of the cookie used to store the transaction state.
+   * The cookie name is derived from the state parameter to prevent collisions
+   * between different transactions.
+   */
+  getTransactionCookieName(state) {
+    return `${this.transactionCookiePrefix}${state}`;
+  }
+  /**
+   * Returns the configured prefix for transaction cookies.
+   */
+  getCookiePrefix() {
+    return this.transactionCookiePrefix;
+  }
+  async save(resCookies, transactionState) {
+    const expiration = Math.floor(Date.now() / 1e3 + this.cookieConfig.maxAge);
+    const jwe = await encrypt(transactionState, this.secret, expiration);
+    if (!transactionState.state) {
+      throw new Error("Transaction state is required");
+    }
+    resCookies.set(this.getTransactionCookieName(transactionState.state), jwe.toString(), this.cookieConfig);
+  }
+  async get(reqCookies, state) {
+    var _a;
+    const cookieName = this.getTransactionCookieName(state);
+    const cookieValue = (_a = reqCookies.get(cookieName)) == null ? void 0 : _a.value;
+    if (!cookieValue) {
+      return null;
+    }
+    return decrypt(cookieValue, this.secret);
+  }
+  async delete(resCookies, state) {
+    await resCookies.delete(this.getTransactionCookieName(state));
+  }
+  /**
+   * Deletes all transaction cookies based on the configured prefix.
+   */
+  async deleteAll(reqCookies, resCookies) {
+    const txnPrefix = this.getCookiePrefix();
+    reqCookies.getAll().forEach((cookie) => {
+      if (cookie.name.startsWith(txnPrefix)) {
+        resCookies.delete(cookie.name);
+      }
+    });
+  }
+}
+export {
+  TransactionStore
+};