@parsrun/auth 0.1.0

package/dist/types-DSjafxJ4.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Multi-runtime KV Storage interface
+ * Supports: Memory, Redis, Cloudflare KV, Deno KV
+ */
+/**
+ * Base KV Storage interface that all adapters must implement
+ */
+interface KVStorage {
+    /**
+     * Get a value by key
+     * @param key - The key to retrieve
+     * @returns The value or null if not found
+     */
+    get<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Set a value with optional TTL
+     * @param key - The key to set
+     * @param value - The value to store
+     * @param ttl - Time to live in seconds (optional)
+     */
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete a key
+     * @param key - The key to delete
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Check if a key exists
+     * @param key - The key to check
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Get multiple values by keys
+     * @param keys - Array of keys to retrieve
+     */
+    getMany?<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    /**
+     * Set multiple values
+     * @param entries - Array of [key, value, ttl?] tuples
+     */
+    setMany?<T = unknown>(entries: Array<[key: string, value: T, ttl?: number]>): Promise<void>;
+    /**
+     * Delete multiple keys
+     * @param keys - Array of keys to delete
+     */
+    deleteMany?(keys: string[]): Promise<void>;
+    /**
+     * Get all keys matching a pattern (optional)
+     * @param pattern - Glob pattern to match
+     */
+    keys?(pattern?: string): Promise<string[]>;
+    /**
+     * Clear all keys (optional, mainly for testing)
+     */
+    clear?(): Promise<void>;
+    /**
+     * Close the connection (for Redis, etc.)
+     */
+    close?(): Promise<void>;
+}
+/**
+ * Storage types
+ */
+type StorageType = 'memory' | 'redis' | 'cloudflare-kv' | 'deno-kv' | 'custom';
+/**
+ * Redis configuration
+ */
+interface RedisConfig {
+    /** Redis connection URL (redis://...) */
+    url?: string;
+    /** Existing Redis client instance */
+    client?: unknown;
+    /** Key prefix for namespacing */
+    prefix?: string;
+}
+/**
+ * Cloudflare KV configuration
+ */
+interface CloudflareKVConfig {
+    /** KV namespace binding */
+    binding: KVNamespace;
+    /** Key prefix for namespacing */
+    prefix?: string;
+}
+/**
+ * Deno KV configuration
+ */
+interface DenoKVConfig {
+    /** Path to KV database (optional, uses default if not provided) */
+    path?: string;
+    /** Key prefix for namespacing */
+    prefix?: string;
+}
+/**
+ * Memory storage configuration
+ */
+interface MemoryConfig {
+    /** Maximum number of entries (default: 10000) */
+    maxSize?: number;
+    /** Key prefix for namespacing */
+    prefix?: string;
+}
+/**
+ * Storage configuration
+ */
+interface StorageConfig {
+    /** Storage type */
+    type?: StorageType;
+    /** Redis configuration */
+    redis?: RedisConfig;
+    /** Cloudflare KV configuration */
+    cloudflareKv?: CloudflareKVConfig;
+    /** Deno KV configuration */
+    denoKv?: DenoKVConfig;
+    /** Memory configuration */
+    memory?: MemoryConfig;
+    /** Custom storage adapter */
+    custom?: KVStorage;
+}
+/**
+ * Cloudflare KV Namespace type (for type safety)
+ */
+interface KVNamespace {
+    get(key: string, options?: {
+        type?: 'text' | 'json' | 'arrayBuffer' | 'stream';
+    }): Promise<string | null>;
+    get(key: string, options: {
+        type: 'json';
+    }): Promise<unknown | null>;
+    put(key: string, value: string | ArrayBuffer | ReadableStream, options?: {
+        expirationTtl?: number;
+        expiration?: number;
+        metadata?: unknown;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(options?: {
+        prefix?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        keys: Array<{
+            name: string;
+            expiration?: number;
+            metadata?: unknown;
+        }>;
+        list_complete: boolean;
+        cursor?: string;
+    }>;
+}
+/**
+ * Deno KV types (for type safety)
+ */
+interface DenoKv {
+    get<T = unknown>(key: Deno.KvKey): Promise<Deno.KvEntryMaybe<T>>;
+    set(key: Deno.KvKey, value: unknown, options?: {
+        expireIn?: number;
+    }): Promise<Deno.KvCommitResult>;
+    delete(key: Deno.KvKey): Promise<void>;
+    list<T = unknown>(selector: Deno.KvListSelector, options?: Deno.KvListOptions): Deno.KvListIterator<T>;
+    close(): void;
+}
+declare namespace Deno {
+    type KvKey = readonly unknown[];
+    interface KvEntryMaybe<T> {
+        key: KvKey;
+        value: T | null;
+        versionstamp: string | null;
+    }
+    interface KvCommitResult {
+        ok: true;
+        versionstamp: string;
+    }
+    interface KvListSelector {
+        prefix?: KvKey;
+        start?: KvKey;
+        end?: KvKey;
+    }
+    interface KvListOptions {
+        limit?: number;
+        cursor?: string;
+        reverse?: boolean;
+        consistency?: 'strong' | 'eventual';
+    }
+    interface KvListIterator<T> extends AsyncIterableIterator<KvEntry<T>> {
+    }
+    interface KvEntry<T> {
+        key: KvKey;
+        value: T;
+        versionstamp: string;
+    }
+}
+
+export type { CloudflareKVConfig as C, DenoKVConfig as D, KVStorage as K, MemoryConfig as M, RedisConfig as R, StorageConfig as S, StorageType as a, KVNamespace as b, DenoKv as c };

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@parsrun/auth",
+  "version": "0.1.0",
+  "description": "Passwordless-first, multi-runtime authentication for Pars framework",
+  "keywords": [
+    "pars",
+    "auth",
+    "authentication",
+    "passwordless",
+    "otp",
+    "multi-tenant",
+    "multi-runtime",
+    "edge",
+    "cloudflare-workers",
+    "deno"
+  ],
+  "homepage": "https://pars.run",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parsrun/pars",
+    "directory": "packages/auth"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.ts",
+      "import": "./dist/storage/index.js"
+    },
+    "./session": {
+      "types": "./dist/session/index.d.ts",
+      "import": "./dist/session/index.js"
+    },
+    "./security": {
+      "types": "./dist/security/index.d.ts",
+      "import": "./dist/security/index.js"
+    },
+    "./providers": {
+      "types": "./dist/providers/index.d.ts",
+      "import": "./dist/providers/index.js"
+    },
+    "./providers/otp": {
+      "types": "./dist/providers/otp/index.d.ts",
+      "import": "./dist/providers/otp/index.js"
+    },
+    "./adapters": {
+      "types": "./dist/adapters/index.d.ts",
+      "import": "./dist/adapters/index.js"
+    },
+    "./adapters/hono": {
+      "types": "./dist/adapters/hono.d.ts",
+      "import": "./dist/adapters/hono.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist node_modules"
+  },
+  "dependencies": {
+    "@parsrun/core": "workspace:*",
+    "@parsrun/types": "workspace:*",
+    "jose": "^5.9.6"
+  },
+  "devDependencies": {
+    "drizzle-orm": "^0.38.4",
+    "hono": "^4.6.14",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "peerDependencies": {
+    "hono": ">=4.0.0",
+    "ioredis": ">=5.0.0",
+    "@upstash/redis": ">=1.0.0",
+    "drizzle-orm": ">=0.30.0"
+  },
+  "peerDependenciesMeta": {
+    "hono": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "@upstash/redis": {
+      "optional": true
+    },
+    "drizzle-orm": {
+      "optional": true
+    }
+  }
+}