@unkey/api 0.5.0-canary.0 → 0.5.0-canary.1

package/dist/index.d.mts

@@ -0,0 +1,199 @@
+type UnkeyOptions = {
+    /**
+     * @default https://api.unkey.dev
+     */
+    baseUrl?: string;
+    /**
+     * The workspace key from unkey.dev
+     */
+    token: string;
+};
+declare class Unkey {
+    readonly baseUrl: string;
+    private readonly token;
+    constructor(opts: UnkeyOptions);
+    private fetch;
+    get keys(): {
+        create: (req: {
+            /**
+             * Provide a name to this key if you want for later reference
+             */
+            name?: string;
+            /**
+             * Choose an API where this key should be created.
+             */
+            apiId: string;
+            /**
+             * To make it easier for your users to understand which product an api key belongs to, you can add prefix them.
+             *
+             * For example Stripe famously prefixes their customer ids with cus_ or their api keys with sk_live_.
+             *
+             * The underscore is automtically added if you are defining a prefix, for example: "prefix": "abc" will result in a key like abc_xxxxxxxxx
+             */
+            prefix?: string;
+            /**
+             * The bytelength used to generate your key determines its entropy as well as its length. Higher is better, but keys become longer and more annoying to handle.
+             *
+             * The default is 16 bytes, or 2128 possible combinations
+             */
+            byteLength?: number;
+            /**
+             * Your user’s Id. This will provide a link between Unkey and your customer record.
+             *
+             * When validating a key, we will return this back to you, so you can clearly identify your user from their api key.
+             */
+            ownerId?: string;
+            /**
+             * This is a place for dynamic meta data, anything that feels useful for you should go here
+             *
+             * Example:
+             *
+             * ```json
+             * {
+             *   "billingTier":"PRO",
+             *   "trialEnds": "2023-06-16T17:16:37.161Z"
+             * }
+             * ```
+             */
+            meta?: unknown;
+            /**
+             * You can auto expire keys by providing a unix timestamp in milliseconds.
+             *
+             * Once keys expire they will automatically be deleted and are no longer valid.
+             */
+            expires?: number;
+            /**
+             * Unkey comes with per-key ratelimiting out of the box.
+             *
+             * @see https://docs.unkey.dev/features/ratelimiting
+             */
+            ratelimit?: {
+                type: "fast" | "consistent";
+                /**
+                 * The total amount of burstable requests.
+                 */
+                limit: number;
+                /**
+                 * How many tokens to refill during each refillInterval
+                 */
+                refillRate: number;
+                /**
+                 * Determines the speed at which tokens are refilled.
+                 * In milliseconds.
+                 */
+                refillInterval: number;
+            };
+            /**
+             * Unkey allows you to set/update usage limits on individual keys
+             *
+             * @see https://docs.unkey.dev/features/remaining
+             */
+            remaining?: number;
+        }) => Promise<{
+            key: string;
+            keyId: string;
+        }>;
+        update: (req: {
+            /**
+             * The id of the key to update.
+             */
+            keyId: string;
+            /**
+             * Update the name
+             */
+            name?: string | null;
+            /**
+             * Update the owner id
+             */
+            ownerId?: string | null;
+            /**
+             * This is a place for dynamic meta data, anything that feels useful for you should go here
+             *
+             * Example:
+             *
+             * ```json
+             * {
+             *   "billingTier":"PRO",
+             *   "trialEnds": "2023-06-16T17:16:37.161Z"
+             * }
+             * ```
+             */
+            meta?: unknown | null;
+            /**
+             * Update the expiration time, Unix timstamp in milliseconds
+             *
+             *
+             */
+            expires?: number | null;
+            /**
+             * Update the ratelimit
+             *
+             * @see https://docs.unkey.dev/features/ratelimiting
+             */
+            ratelimit?: {
+                type: "fast" | "consistent";
+                /**
+                 * The total amount of burstable requests.
+                 */
+                limit: number;
+                /**
+                 * How many tokens to refill during each refillInterval
+                 */
+                refillRate: number;
+                /**
+                 * Determines the speed at which tokens are refilled.
+                 * In milliseconds.
+                 */
+                refillInterval: number;
+            } | null;
+            /**
+             * Update the remaining verifications.
+             *
+             * @see https://docs.unkey.dev/features/remaining
+             */
+            remaining?: number | null;
+        }) => Promise<{
+            key: string;
+            keyId: string;
+        }>;
+        verify: (req: {
+            key: string;
+        }) => Promise<{
+            /**
+             * Whether or not this key is valid and has passed the ratelimit. If false you should not grant access to whatever the user is requesting
+             */
+            valid: boolean;
+            /**
+             * If you have set an ownerId on this key it is returned here. You can use this to clearly authenticate a user in your system.
+             */
+            ownerId?: string;
+            meta?: unknown;
+        }>;
+        revoke: (req: {
+            keyId: string;
+        }) => Promise<void>;
+    };
+    /**
+     * Must be authenticated via app token
+     */
+    get _internal(): {
+        createRootKey: (req: {
+            /**
+             * Provide a name to this key if you want for later reference
+             */
+            name?: string;
+            /**
+             * You can auto expire keys by providing a unix timestamp in milliseconds.
+             *
+             * Once keys expire they will automatically be deleted and are no longer valid.
+             */
+            expires?: number;
+            forWorkspaceId: string;
+        }) => Promise<{
+            key: string;
+            keyId: string;
+        }>;
+    };
+}
+
+export { Unkey, UnkeyOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unkey/api",
-  "version": "0.5.0-canary.0",
+  "version": "0.5.0-canary.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "license": "MIT",
@@ -19,10 +19,10 @@
   ],
   "author": "Andreas Thomas <andreas@chronark.com>",
   "devDependencies": {
-    "@types/node": "^20.2.1",
-    "tsup": "^7.0.0",
+    "@types/node": "^20.4.4",
+    "tsup": "^7.1.0",
     "tsx": "^3.12.7",
-    "typescript": "^5.0.4"
+    "typescript": "^5.1.6"
   },
   "scripts": {
     "build": "tsup"