@_mustachio/openauth 0.6.0

package/dist/esm/provider/yahoo.js

@@ -0,0 +1,15 @@
+// src/provider/yahoo.ts
+import { Oauth2Provider } from "./oauth2.js";
+function YahooProvider(config) {
+  return Oauth2Provider({
+    ...config,
+    type: "yahoo",
+    endpoint: {
+      authorization: "https://api.login.yahoo.com/oauth2/request_auth",
+      token: "https://api.login.yahoo.com/oauth2/get_token"
+    }
+  });
+}
+export {
+  YahooProvider
+};

package/dist/esm/random.js

@@ -0,0 +1,27 @@
+// src/random.ts
+import { timingSafeEqual } from "node:crypto";
+function generateUnbiasedDigits(length) {
+  const result = [];
+  while (result.length < length) {
+    const buffer = crypto.getRandomValues(new Uint8Array(length * 2));
+    for (const byte of buffer) {
+      if (byte < 250 && result.length < length) {
+        result.push(byte % 10);
+      }
+    }
+  }
+  return result.join("");
+}
+function timingSafeCompare(a, b) {
+  if (typeof a !== "string" || typeof b !== "string") {
+    return false;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+export {
+  timingSafeCompare,
+  generateUnbiasedDigits
+};

package/dist/esm/storage/aws.js

@@ -0,0 +1,39 @@
+// src/storage/aws.ts
+import { AwsClient } from "aws4fetch";
+var cachedCredentials = null;
+async function getCredentials(url) {
+  if (cachedCredentials) {
+    const currentTime = new Date;
+    const fiveMinutesFromNow = new Date(currentTime.getTime() + 5 * 60000);
+    const expirationTime = new Date(cachedCredentials.Expiration);
+    if (expirationTime > fiveMinutesFromNow) {
+      return cachedCredentials;
+    }
+  }
+  const credentials = await fetch(url).then((res) => res.json());
+  cachedCredentials = credentials;
+  return credentials;
+}
+async function client() {
+  if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
+    return new AwsClient({
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      sessionToken: process.env.AWS_SESSION_TOKEN,
+      region: process.env.AWS_REGION
+    });
+  }
+  if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
+    const credentials = await getCredentials("http://169.254.170.2" + process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI);
+    return new AwsClient({
+      accessKeyId: credentials.AccessKeyId,
+      secretAccessKey: credentials.SecretAccessKey,
+      sessionToken: credentials.Token,
+      region: process.env.AWS_REGION
+    });
+  }
+  throw new Error("No AWS credentials found");
+}
+export {
+  client
+};

package/dist/esm/storage/cloudflare.js

@@ -0,0 +1,42 @@
+// src/storage/cloudflare.ts
+import { joinKey, splitKey } from "./storage.js";
+function CloudflareStorage(options) {
+  return {
+    async get(key) {
+      const value = await options.namespace.get(joinKey(key), "json");
+      if (!value)
+        return;
+      return value;
+    },
+    async set(key, value, expiry) {
+      await options.namespace.put(joinKey(key), JSON.stringify(value), {
+        expirationTtl: expiry ? Math.max(Math.floor((expiry.getTime() - Date.now()) / 1000), 60) : undefined
+      });
+    },
+    async remove(key) {
+      await options.namespace.delete(joinKey(key));
+    },
+    async* scan(prefix) {
+      let cursor;
+      while (true) {
+        const result = await options.namespace.list({
+          prefix: joinKey([...prefix, ""]),
+          cursor
+        });
+        for (const key of result.keys) {
+          const value = await options.namespace.get(key.name, "json");
+          if (value !== null) {
+            yield [splitKey(key.name), value];
+          }
+        }
+        if (result.list_complete) {
+          break;
+        }
+        cursor = result.cursor;
+      }
+    }
+  };
+}
+export {
+  CloudflareStorage
+};

package/dist/esm/storage/dynamo.js

@@ -0,0 +1,116 @@
+// src/storage/dynamo.ts
+import { client } from "./aws.js";
+import { joinKey } from "./storage.js";
+function DynamoStorage(options) {
+  const pk = options.pk || "pk";
+  const sk = options.sk || "sk";
+  const ttl = options.ttl || "expiry";
+  const tableName = options.table;
+  function parseKey(key) {
+    if (key.length === 2) {
+      return {
+        pk: key[0],
+        sk: key[1]
+      };
+    }
+    return {
+      pk: joinKey(key.slice(0, 2)),
+      sk: joinKey(key.slice(2))
+    };
+  }
+  async function dynamo(action, payload) {
+    const c = await client();
+    const endpoint = options.endpoint || `https://dynamodb.${c.region}.amazonaws.com`;
+    const response = await c.fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-amz-json-1.0",
+        "X-Amz-Target": `DynamoDB_20120810.${action}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`DynamoDB request failed: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  return {
+    async get(key) {
+      const { pk: keyPk, sk: keySk } = parseKey(key);
+      const params = {
+        TableName: tableName,
+        Key: {
+          [pk]: { S: keyPk },
+          [sk]: { S: keySk }
+        }
+      };
+      const result = await dynamo("GetItem", params);
+      if (!result.Item)
+        return;
+      if (result.Item[ttl] && result.Item[ttl].N < Date.now() / 1000) {
+        return;
+      }
+      return JSON.parse(result.Item.value.S);
+    },
+    async set(key, value, expiry) {
+      const parsed = parseKey(key);
+      const params = {
+        TableName: tableName,
+        Item: {
+          [pk]: { S: parsed.pk },
+          [sk]: { S: parsed.sk },
+          ...expiry ? {
+            [ttl]: { N: Math.floor(expiry.getTime() / 1000).toString() }
+          } : {},
+          value: { S: JSON.stringify(value) }
+        }
+      };
+      await dynamo("PutItem", params);
+    },
+    async remove(key) {
+      const { pk: keyPk, sk: keySk } = parseKey(key);
+      const params = {
+        TableName: tableName,
+        Key: {
+          [pk]: { S: keyPk },
+          [sk]: { S: keySk }
+        }
+      };
+      await dynamo("DeleteItem", params);
+    },
+    async* scan(prefix) {
+      const prefixPk = prefix.length >= 2 ? joinKey(prefix.slice(0, 2)) : prefix[0];
+      const prefixSk = prefix.length > 2 ? joinKey(prefix.slice(2)) : "";
+      let lastEvaluatedKey = undefined;
+      const now = Date.now() / 1000;
+      while (true) {
+        const params = {
+          TableName: tableName,
+          ExclusiveStartKey: lastEvaluatedKey,
+          KeyConditionExpression: prefixSk ? `#pk = :pk AND begins_with(#sk, :sk)` : `#pk = :pk`,
+          ExpressionAttributeNames: {
+            "#pk": pk,
+            ...prefixSk && { "#sk": sk }
+          },
+          ExpressionAttributeValues: {
+            ":pk": { S: prefixPk },
+            ...prefixSk && { ":sk": { S: prefixSk } }
+          }
+        };
+        const result = await dynamo("Query", params);
+        for (const item of result.Items || []) {
+          if (item[ttl] && item[ttl].N < now) {
+            continue;
+          }
+          yield [[item[pk].S, item[sk].S], JSON.parse(item.value.S)];
+        }
+        if (!result.LastEvaluatedKey)
+          break;
+        lastEvaluatedKey = result.LastEvaluatedKey;
+      }
+    }
+  };
+}
+export {
+  DynamoStorage
+};

package/dist/esm/storage/memory.js

@@ -0,0 +1,88 @@
+// src/storage/memory.ts
+import { joinKey, splitKey } from "./storage.js";
+import { existsSync, readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+function MemoryStorage(input) {
+  const store = [];
+  if (input?.persist) {
+    if (existsSync(input.persist)) {
+      const file = readFileSync(input?.persist);
+      store.push(...JSON.parse(file.toString()));
+    }
+  }
+  async function save() {
+    if (!input?.persist)
+      return;
+    const file = JSON.stringify(store);
+    await writeFile(input.persist, file);
+  }
+  function search(key) {
+    let left = 0;
+    let right = store.length - 1;
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const comparison = key.localeCompare(store[mid][0]);
+      if (comparison === 0) {
+        return { found: true, index: mid };
+      } else if (comparison < 0) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    }
+    return { found: false, index: left };
+  }
+  return {
+    async get(key) {
+      const match = search(joinKey(key));
+      if (!match.found)
+        return;
+      const entry = store[match.index][1];
+      if (entry.expiry && Date.now() >= entry.expiry) {
+        store.splice(match.index, 1);
+        await save();
+        return;
+      }
+      return entry.value;
+    },
+    async set(key, value, expiry) {
+      const joined = joinKey(key);
+      const match = search(joined);
+      const entry = [
+        joined,
+        {
+          value,
+          expiry: expiry ? expiry.getTime() : expiry
+        }
+      ];
+      if (!match.found) {
+        store.splice(match.index, 0, entry);
+      } else {
+        store[match.index] = entry;
+      }
+      await save();
+    },
+    async remove(key) {
+      const joined = joinKey(key);
+      const match = search(joined);
+      if (match.found) {
+        store.splice(match.index, 1);
+        await save();
+      }
+    },
+    async* scan(prefix) {
+      const now = Date.now();
+      const prefixStr = joinKey(prefix);
+      for (const [key, entry] of store) {
+        if (!key.startsWith(prefixStr))
+          continue;
+        if (entry.expiry && now >= entry.expiry)
+          continue;
+        yield [splitKey(key), entry.value];
+      }
+    }
+  };
+}
+export {
+  MemoryStorage
+};

package/dist/esm/storage/storage.js

@@ -0,0 +1,36 @@
+// src/storage/storage.ts
+var SEPERATOR = String.fromCharCode(31);
+function joinKey(key) {
+  return key.join(SEPERATOR);
+}
+function splitKey(key) {
+  return key.split(SEPERATOR);
+}
+var Storage;
+((Storage) => {
+  function encode(key) {
+    return key.map((k) => k.replaceAll(SEPERATOR, ""));
+  }
+  function get(adapter, key) {
+    return adapter.get(encode(key));
+  }
+  Storage.get = get;
+  function set(adapter, key, value, ttl) {
+    const expiry = ttl ? new Date(Date.now() + ttl * 1000) : undefined;
+    return adapter.set(encode(key), value, expiry);
+  }
+  Storage.set = set;
+  function remove(adapter, key) {
+    return adapter.remove(encode(key));
+  }
+  Storage.remove = remove;
+  function scan(adapter, key) {
+    return adapter.scan(encode(key));
+  }
+  Storage.scan = scan;
+})(Storage ||= {});
+export {
+  splitKey,
+  joinKey,
+  Storage
+};

package/dist/esm/subject.js

@@ -0,0 +1,7 @@
+// src/subject.ts
+function createSubjects(types) {
+  return { ...types };
+}
+export {
+  createSubjects
+};