@_mustachio/openauth 0.9.2 → 0.11.0

package/dist/esm/provider/yahoo.js

@@ -1,15 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-// 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

@@ -1,39 +0,0 @@
-// 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

@@ -1,42 +0,0 @@
-// 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

@@ -1,116 +0,0 @@
-// 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

@@ -1,88 +0,0 @@
-// 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

@@ -1,36 +0,0 @@
-// 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

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