@farm.js/unkey 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Farm.js Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,11 @@
+# @farm.js/unkey
+
+Unkey integration for Farm.js
+
+Farm.js is currently in beta.
+
+```bash
+npm install @farm.js/unkey@beta
+```
+
+See the [Farm.js repository](https://github.com/farming-labs/farm.js) for documentation, examples, and support.

package/dist/index.d.ts

@@ -0,0 +1,463 @@
+import { type FarmIntegrationHandlerContext, type FarmIntegrationLogger } from "@farm.js/core";
+export interface UnkeyAPIEnvelope<TData> {
+    meta?: {
+        requestId?: string;
+        [key: string]: unknown;
+    };
+    data: TData;
+}
+export interface UnkeyRatelimitRequest {
+    name: string;
+    limit?: number;
+    duration?: number;
+    cost?: number;
+    autoApply?: boolean;
+}
+export interface UnkeyCreditsInput {
+    remaining?: number | null;
+    refill?: {
+        interval: "daily" | "monthly";
+        amount: number;
+        refillDay?: number;
+    } | null;
+}
+export interface UnkeyCreateKeyInput {
+    apiId?: string;
+    prefix?: string;
+    name?: string;
+    byteLength?: number;
+    externalId?: string;
+    meta?: Record<string, unknown>;
+    roles?: string[];
+    permissions?: string[];
+    expires?: number;
+    credits?: UnkeyCreditsInput;
+    ratelimits?: UnkeyRatelimitRequest[];
+}
+export interface UnkeyCreateKeyResult {
+    keyId: string;
+    key: string;
+}
+export interface UnkeyVerifyKeyInput {
+    key: string;
+    tags?: string[];
+    permissions?: string;
+    credits?: {
+        cost?: number;
+    };
+    ratelimits?: Array<{
+        name: string;
+        cost?: number;
+        limit?: number;
+        duration?: number;
+    }>;
+    migrationId?: string;
+}
+export interface UnkeyVerificationIdentity {
+    id?: string;
+    externalId?: string;
+    meta?: Record<string, unknown>;
+    ratelimits?: UnkeyRatelimitRequest[];
+}
+export interface UnkeyRatelimitState {
+    exceeded?: boolean;
+    id?: string;
+    name?: string;
+    limit?: number;
+    duration?: number;
+    reset?: number;
+    remaining?: number;
+    autoApply?: boolean;
+}
+export interface UnkeyVerifyKeyResult {
+    valid: boolean;
+    code?: string;
+    keyId?: string;
+    name?: string;
+    meta?: Record<string, unknown>;
+    expires?: number;
+    credits?: number;
+    enabled?: boolean;
+    permissions?: string[];
+    roles?: string[];
+    identity?: UnkeyVerificationIdentity;
+    ratelimits?: UnkeyRatelimitState[];
+}
+export interface UnkeyUpdateKeyInput {
+    keyId: string;
+    name?: string | null;
+    externalId?: string | null;
+    meta?: Record<string, unknown> | null;
+    expires?: number | null;
+    credits?: UnkeyCreditsInput | null;
+    ratelimits?: UnkeyRatelimitRequest[] | null;
+    enabled?: boolean;
+    roles?: string[];
+    permissions?: string[];
+}
+export interface UnkeyDeleteKeyInput {
+    keyId: string;
+    permanent?: boolean;
+}
+export interface UnkeyRevokeKeyInput {
+    keyId: string;
+}
+export interface UnkeyClient {
+    createKey(input: UnkeyCreateKeyInput): Promise<UnkeyCreateKeyResult>;
+    verifyKey(input: UnkeyVerifyKeyInput): Promise<UnkeyVerifyKeyResult>;
+    updateKey(input: UnkeyUpdateKeyInput): Promise<Record<string, never>>;
+    revokeKey(input: UnkeyRevokeKeyInput): Promise<Record<string, never>>;
+    deleteKey(input: UnkeyDeleteKeyInput): Promise<Record<string, never>>;
+}
+export interface UnkeyClientOptions {
+    rootKey?: string;
+    apiId?: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+}
+export declare class UnkeyAPIError<TData = unknown> extends Error {
+    readonly status: number;
+    readonly requestId: string | undefined;
+    readonly data: TData | undefined;
+    constructor(message: string, options: {
+        status: number;
+        requestId?: string;
+        data?: TData;
+    });
+}
+export declare function createUnkeyClient(options?: UnkeyClientOptions): UnkeyClient;
+export interface UnkeyIntegrationPaths {
+    basePath?: string;
+    create?: string;
+    verify?: string;
+    update?: string;
+    revoke?: string;
+    deleteKey?: string;
+}
+export interface UnkeyProtectionOptions {
+    matcher?: string | string[];
+    headers?: string | string[];
+    permissions?: string;
+    tags?: string[] | ((request: Request, context: FarmIntegrationHandlerContext) => string[]);
+    contextKey?: string;
+    exposeToPage?: boolean;
+    onVerified?: (request: Request, context: FarmIntegrationHandlerContext, result: UnkeyVerifyKeyResult) => Promise<Response | void> | Response | void;
+    onDenied?: (request: Request, context: FarmIntegrationHandlerContext, result: UnkeyVerifyKeyResult | {
+        valid: false;
+        code: "MISSING_KEY" | "VERIFY_ERROR";
+    }) => Promise<Response | void> | Response | void;
+}
+export interface UnkeyIntegrationInput extends UnkeyClientOptions {
+    client?: UnkeyClient;
+    paths?: UnkeyIntegrationPaths;
+    protectedRoutes?: string | string[];
+    protection?: UnkeyProtectionOptions;
+    log?: FarmIntegrationLogger;
+}
+interface ResolvedUnkeyConfig {
+    rootKey?: string;
+    apiId?: string;
+    baseUrl: string;
+}
+export declare function unkey(input?: UnkeyIntegrationInput): import("@farm.js/core").DefinedIntegration<{
+    category: "auth";
+    type: string;
+    instance: {
+        apiId: string | undefined;
+        baseUrl: string;
+        client: UnkeyClient;
+    };
+    api: {
+        [x: string]: {
+            post: {
+                readonly kind: "farm-integration-api-operation";
+                path: string;
+                method: "POST";
+                bodyFormat?: import("@farm.js/core/client").FarmIntegrationAPIBodyFormat | undefined;
+                responseFormat?: import("@farm.js/core/client").FarmIntegrationAPIResponseFormat | undefined;
+                headers?: {
+                    [x: string]: string;
+                } | undefined;
+                credentials?: RequestCredentials | undefined;
+                isServer?: true | undefined;
+                __pathless?: boolean | undefined;
+                __types?: {
+                    body: {
+                        apiId?: string | undefined;
+                        prefix?: string | undefined;
+                        name?: string | undefined;
+                        byteLength?: number | undefined;
+                        externalId?: string | undefined;
+                        meta?: {
+                            [x: string]: unknown;
+                        } | undefined;
+                        roles?: string[] | undefined;
+                        permissions?: {
+                            [x: number]: string;
+                            length: number;
+                            toString: (() => string) & (() => string);
+                            toLocaleString: {
+                                (): string;
+                                (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+                            };
+                            pop: () => string | undefined;
+                            push: (...items: string[]) => number;
+                            concat: {
+                                (...items: ConcatArray<string>[]): string[];
+                                (...items: (string | ConcatArray<string>)[]): string[];
+                            } & ((...strings: string[]) => string);
+                            join: (separator?: string) => string;
+                            reverse: () => string[];
+                            shift: () => string | undefined;
+                            slice: ((start?: number, end?: number) => string[]) & ((start?: number, end?: number) => string);
+                            sort: (compareFn?: ((a: string, b: string) => number) | undefined) => string[] & string;
+                            splice: {
+                                (start: number, deleteCount?: number): string[];
+                                (start: number, deleteCount: number, ...items: string[]): string[];
+                            };
+                            unshift: (...items: string[]) => number;
+                            indexOf: ((searchElement: string, fromIndex?: number) => number) & ((searchString: string, position?: number) => number);
+                            lastIndexOf: ((searchElement: string, fromIndex?: number) => number) & ((searchString: string, position?: number) => number);
+                            every: {
+                                <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
+                                (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+                            };
+                            some: (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any) => boolean;
+                            forEach: (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void;
+                            map: <U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[];
+                            filter: {
+                                <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[];
+                                (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
+                            };
+                            reduce: {
+                                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+                                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+                                <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+                            };
+                            reduceRight: {
+                                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+                                (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+                                <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+                            };
+                            find: {
+                                <S extends string>(predicate: (value: string, index: number, obj: string[]) => value is S, thisArg?: any): S | undefined;
+                                (predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string | undefined;
+                            };
+                            findIndex: (predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any) => number;
+                            fill: (value: string, start?: number, end?: number) => string[] & string;
+                            copyWithin: (target: number, start: number, end?: number) => string[] & string;
+                            entries: () => ArrayIterator<[number, string]>;
+                            keys: () => ArrayIterator<number>;
+                            values: () => ArrayIterator<string>;
+                            includes: ((searchElement: string, fromIndex?: number) => boolean) & ((searchString: string, position?: number) => boolean);
+                            flatMap: <U, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U | readonly U[], thisArg?: This | undefined) => U[];
+                            flat: <A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[];
+                            at: ((index: number) => string | undefined) & ((index: number) => string | undefined);
+                            [Symbol.iterator]: (() => ArrayIterator<string>) & (() => StringIterator<string>);
+                            readonly [Symbol.unscopables]: {
+                                [x: number]: boolean | undefined;
+                                length?: boolean | undefined;
+                                toString?: boolean | undefined;
+                                toLocaleString?: boolean | undefined;
+                                pop?: boolean | undefined;
+                                push?: boolean | undefined;
+                                concat?: boolean | undefined;
+                                join?: boolean | undefined;
+                                reverse?: boolean | undefined;
+                                shift?: boolean | undefined;
+                                slice?: boolean | undefined;
+                                sort?: boolean | undefined;
+                                splice?: boolean | undefined;
+                                unshift?: boolean | undefined;
+                                indexOf?: boolean | undefined;
+                                lastIndexOf?: boolean | undefined;
+                                every?: boolean | undefined;
+                                some?: boolean | undefined;
+                                forEach?: boolean | undefined;
+                                map?: boolean | undefined;
+                                filter?: boolean | undefined;
+                                reduce?: boolean | undefined;
+                                reduceRight?: boolean | undefined;
+                                find?: boolean | undefined;
+                                findIndex?: boolean | undefined;
+                                fill?: boolean | undefined;
+                                copyWithin?: boolean | undefined;
+                                entries?: boolean | undefined;
+                                keys?: boolean | undefined;
+                                values?: boolean | undefined;
+                                includes?: boolean | undefined;
+                                flatMap?: boolean | undefined;
+                                flat?: boolean | undefined;
+                                at?: boolean | undefined;
+                                [Symbol.iterator]?: boolean | undefined;
+                                readonly [Symbol.unscopables]?: boolean | undefined;
+                            };
+                            charAt: (pos: number) => string;
+                            charCodeAt: (index: number) => number;
+                            localeCompare: {
+                                (that: string): number;
+                                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                                (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+                            };
+                            match: {
+                                (regexp: string | RegExp): RegExpMatchArray | null;
+                                (matcher: {
+                                    [Symbol.match](string: string): RegExpMatchArray | null;
+                                }): RegExpMatchArray | null;
+                            };
+                            replace: {
+                                (searchValue: string | RegExp, replaceValue: string): string;
+                                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                                (searchValue: {
+                                    [Symbol.replace](string: string, replaceValue: string): string;
+                                }, replaceValue: string): string;
+                                (searchValue: {
+                                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                                }, replacer: (substring: string, ...args: any[]) => string): string;
+                            };
+                            search: {
+                                (regexp: string | RegExp): number;
+                                (searcher: {
+                                    [Symbol.search](string: string): number;
+                                }): number;
+                            };
+                            split: {
+                                (separator: string | RegExp, limit?: number): string[];
+                                (splitter: {
+                                    [Symbol.split](string: string, limit?: number): string[];
+                                }, limit?: number): string[];
+                            };
+                            substring: (start: number, end?: number) => string;
+                            toLowerCase: () => string;
+                            toLocaleLowerCase: {
+                                (locales?: string | string[]): string;
+                                (locales?: Intl.LocalesArgument): string;
+                            };
+                            toUpperCase: () => string;
+                            toLocaleUpperCase: {
+                                (locales?: string | string[]): string;
+                                (locales?: Intl.LocalesArgument): string;
+                            };
+                            trim: () => string;
+                            substr: (from: number, length?: number) => string;
+                            valueOf: () => string;
+                            codePointAt: (pos: number) => number | undefined;
+                            endsWith: (searchString: string, endPosition?: number) => boolean;
+                            normalize: {
+                                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                                (form?: string): string;
+                            };
+                            repeat: (count: number) => string;
+                            startsWith: (searchString: string, position?: number) => boolean;
+                            anchor: (name: string) => string;
+                            big: () => string;
+                            blink: () => string;
+                            bold: () => string;
+                            fixed: () => string;
+                            fontcolor: (color: string) => string;
+                            fontsize: {
+                                (size: number): string;
+                                (size: string): string;
+                            };
+                            italics: () => string;
+                            link: (url: string) => string;
+                            small: () => string;
+                            strike: () => string;
+                            sub: () => string;
+                            sup: () => string;
+                            padStart: (maxLength: number, fillString?: string) => string;
+                            padEnd: (maxLength: number, fillString?: string) => string;
+                            trimEnd: () => string;
+                            trimStart: () => string;
+                            trimLeft: () => string;
+                            trimRight: () => string;
+                            matchAll: (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>;
+                            replaceAll: {
+                                (searchValue: string | RegExp, replaceValue: string): string;
+                                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                            };
+                        } | undefined;
+                        expires?: number | undefined;
+                        credits?: {
+                            remaining?: number | null | undefined;
+                            refill?: {
+                                interval: "daily" | "monthly";
+                                amount: number;
+                                refillDay?: number | undefined;
+                            } | null | undefined;
+                            cost?: number | undefined;
+                        } | undefined;
+                        ratelimits?: ({
+                            name: string;
+                            limit?: number | undefined;
+                            duration?: number | undefined;
+                            cost?: number | undefined;
+                            autoApply?: boolean | undefined;
+                        }[] & {
+                            name: string;
+                            cost?: number | undefined;
+                            limit?: number | undefined;
+                            duration?: number | undefined;
+                        }[]) | undefined;
+                        key: string;
+                        tags?: string[] | undefined;
+                        migrationId?: string | undefined;
+                        keyId: string;
+                        enabled?: boolean | undefined;
+                        permanent?: boolean | undefined;
+                    };
+                    query: never;
+                    response: {
+                        [x: string]: never;
+                        keyId: string;
+                        key: string;
+                        valid: boolean;
+                        code?: string | undefined;
+                        name?: string | undefined;
+                        meta?: {
+                            [x: string]: unknown;
+                        } | undefined;
+                        expires?: number | undefined;
+                        credits?: number | undefined;
+                        enabled?: boolean | undefined;
+                        permissions?: string[] | undefined;
+                        roles?: string[] | undefined;
+                        identity?: {
+                            id?: string | undefined;
+                            externalId?: string | undefined;
+                            meta?: {
+                                [x: string]: unknown;
+                            } | undefined;
+                            ratelimits?: {
+                                name: string;
+                                limit?: number | undefined;
+                                duration?: number | undefined;
+                                cost?: number | undefined;
+                                autoApply?: boolean | undefined;
+                            }[] | undefined;
+                        } | undefined;
+                        ratelimits?: {
+                            exceeded?: boolean | undefined;
+                            id?: string | undefined;
+                            name?: string | undefined;
+                            limit?: number | undefined;
+                            duration?: number | undefined;
+                            reset?: number | undefined;
+                            remaining?: number | undefined;
+                            autoApply?: boolean | undefined;
+                        }[] | undefined;
+                    };
+                } | undefined;
+            };
+        };
+    };
+    config: import("@farm.js/core").FarmIntegrationConfigDefinition<ResolvedUnkeyConfig, import("@farm.js/core").FarmIntegrationSchema | undefined>;
+    log: FarmIntegrationLogger | undefined;
+    middleware: {
+        matcher: string | string[];
+        handler(request: Request, context: FarmIntegrationHandlerContext<unknown, unknown, import("@farm.js/core").FarmIntegrationSchema | undefined>): Promise<void | Response>;
+    }[] | undefined;
+    routes: (import("@farm.js/core").FarmTypedIntegrationRoute<string, UnkeyCreateKeyInput, never, UnkeyCreateKeyResult, true, "POST", import("@farm.js/core").FarmIntegrationSchema | undefined> | import("@farm.js/core").FarmTypedIntegrationRoute<string, UnkeyVerifyKeyInput, never, UnkeyVerifyKeyResult, true, "POST", import("@farm.js/core").FarmIntegrationSchema | undefined> | import("@farm.js/core").FarmTypedIntegrationRoute<string, UnkeyRevokeKeyInput, never, Record<string, never>, true, "POST", import("@farm.js/core").FarmIntegrationSchema | undefined>)[];
+}>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,380 @@
+import { FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY, defineIntegration, integrationRoute, } from "@farm.js/core";
+import { api as clientApi } from "@farm.js/core/client";
+import { createPathInferredClientApi, integrationConfig } from "@farm.js/integration-utils";
+const DEFAULT_UNKEY_BASE_URL = "https://api.unkey.com";
+export class UnkeyAPIError extends Error {
+    status;
+    requestId;
+    data;
+    constructor(message, options) {
+        super(message);
+        this.name = "UnkeyAPIError";
+        this.status = options.status;
+        this.requestId = options.requestId;
+        this.data = options.data;
+    }
+}
+export function createUnkeyClient(options = {}) {
+    return new UnkeyHttpClient(options);
+}
+class UnkeyHttpClient {
+    rootKey;
+    apiId;
+    baseUrl;
+    fetchImpl;
+    constructor(options) {
+        this.rootKey = options.rootKey ?? process.env.UNKEY_ROOT_KEY ?? undefined;
+        this.apiId = options.apiId ?? process.env.UNKEY_API_ID ?? undefined;
+        this.baseUrl = options.baseUrl ?? process.env.UNKEY_BASE_URL ?? DEFAULT_UNKEY_BASE_URL;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    createKey(input) {
+        const apiId = input.apiId ?? this.apiId;
+        if (!apiId) {
+            throw new Error("Unkey createKey requires UNKEY_API_ID, options.apiId, or input.apiId.");
+        }
+        return this.request("keys.createKey", {
+            ...input,
+            apiId,
+        });
+    }
+    verifyKey(input) {
+        return this.request("keys.verifyKey", input);
+    }
+    updateKey(input) {
+        return this.request("keys.updateKey", input);
+    }
+    revokeKey(input) {
+        return this.updateKey({
+            keyId: input.keyId,
+            enabled: false,
+        });
+    }
+    deleteKey(input) {
+        return this.request("keys.deleteKey", input);
+    }
+    async request(operation, body) {
+        if (!this.rootKey) {
+            throw new Error("Unkey client requires UNKEY_ROOT_KEY or options.rootKey.");
+        }
+        const response = await this.fetchImpl(`${this.baseUrl.replace(/\/+$/, "")}/v2/${operation}`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.rootKey}`,
+                "content-type": "application/json",
+                accept: "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        const payload = await parseUnkeyResponse(response);
+        if (!response.ok) {
+            throw createUnkeyError(response, payload);
+        }
+        return (payload.data ?? {});
+    }
+}
+async function parseUnkeyResponse(response) {
+    const text = await response.text();
+    if (!text) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {
+            message: text,
+        };
+    }
+}
+function createUnkeyError(response, payload) {
+    const data = isRecord(payload) ? payload : undefined;
+    const error = isRecord(data?.error) ? data.error : undefined;
+    const message = getString(error?.message) ||
+        getString(data?.message) ||
+        response.statusText ||
+        "Unkey API request failed.";
+    const requestId = getString(data?.requestId) ||
+        (isRecord(data?.meta) ? getString(data.meta.requestId) : undefined);
+    return new UnkeyAPIError(message, {
+        status: response.status,
+        requestId,
+        data,
+    });
+}
+function createUnkeyApi(paths) {
+    return createPathInferredClientApi({
+        path: paths.create,
+        operation: clientApi.post(paths.create, {
+            responseFormat: "json",
+            isServer: true,
+        }),
+    }, {
+        path: paths.verify,
+        operation: clientApi.post(paths.verify, {
+            responseFormat: "json",
+            isServer: true,
+        }),
+    }, {
+        path: paths.update,
+        operation: clientApi.post(paths.update, {
+            responseFormat: "json",
+            isServer: true,
+        }),
+    }, {
+        path: paths.revoke,
+        operation: clientApi.post(paths.revoke, {
+            responseFormat: "json",
+            isServer: true,
+        }),
+    }, {
+        path: paths.deleteKey,
+        operation: clientApi.post(paths.deleteKey, {
+            responseFormat: "json",
+            isServer: true,
+        }),
+    });
+}
+export function unkey(input = {}) {
+    const config = resolveUnkeyConfig(input);
+    const paths = resolveUnkeyPaths(input.paths);
+    const hasInjectedClient = !!input.client;
+    const client = input.client ?? createUnkeyClient(config);
+    const protection = input.protection;
+    const protectedRoutes = input.protectedRoutes ?? protection?.matcher;
+    return defineIntegration({
+        category: "auth",
+        type: "unkey",
+        instance: {
+            apiId: config.apiId,
+            baseUrl: config.baseUrl,
+            client,
+        },
+        api: createUnkeyApi(paths),
+        config: integrationConfig({
+            label: "Unkey integration",
+            env: {
+                rootKey: "UNKEY_ROOT_KEY",
+                apiId: "UNKEY_API_ID",
+                baseUrl: "UNKEY_BASE_URL",
+            },
+            defaults: {
+                baseUrl: DEFAULT_UNKEY_BASE_URL,
+            },
+            input: config,
+            required: hasInjectedClient ? [] : ["rootKey"],
+        }),
+        log: input.log,
+        middleware: protectedRoutes
+            ? [
+                {
+                    matcher: protectedRoutes,
+                    handler(request, context) {
+                        return verifyProtectedRequest(request, context, client, protection);
+                    },
+                },
+            ]
+            : undefined,
+        routes: [
+            integrationRoute.post(paths.create, {
+                responseFormat: "json",
+                isServer: true,
+                async handler(request, context) {
+                    const blocked = ensureInternalServerCall(context);
+                    if (blocked) {
+                        return blocked;
+                    }
+                    const body = await readJsonBody(request);
+                    if (!hasInjectedClient && !body.apiId && !config.apiId) {
+                        return Response.json({
+                            error: "Unkey create key requires UNKEY_API_ID, options.apiId, or body.apiId.",
+                        }, {
+                            status: 400,
+                        });
+                    }
+                    return Response.json(await client.createKey({
+                        ...body,
+                        apiId: body.apiId ?? config.apiId,
+                    }));
+                },
+            }),
+            integrationRoute.post(paths.verify, {
+                responseFormat: "json",
+                isServer: true,
+                async handler(request, context) {
+                    const blocked = ensureInternalServerCall(context);
+                    if (blocked) {
+                        return blocked;
+                    }
+                    return Response.json(await client.verifyKey(await readJsonBody(request)));
+                },
+            }),
+            integrationRoute.post(paths.update, {
+                responseFormat: "json",
+                isServer: true,
+                async handler(request, context) {
+                    const blocked = ensureInternalServerCall(context);
+                    if (blocked) {
+                        return blocked;
+                    }
+                    return Response.json(await client.updateKey(await readJsonBody(request)));
+                },
+            }),
+            integrationRoute.post(paths.revoke, {
+                responseFormat: "json",
+                isServer: true,
+                async handler(request, context) {
+                    const blocked = ensureInternalServerCall(context);
+                    if (blocked) {
+                        return blocked;
+                    }
+                    return Response.json(await client.revokeKey(await readJsonBody(request)));
+                },
+            }),
+            integrationRoute.post(paths.deleteKey, {
+                responseFormat: "json",
+                isServer: true,
+                async handler(request, context) {
+                    const blocked = ensureInternalServerCall(context);
+                    if (blocked) {
+                        return blocked;
+                    }
+                    return Response.json(await client.deleteKey(await readJsonBody(request)));
+                },
+            }),
+        ],
+    });
+}
+function resolveUnkeyConfig(input) {
+    return {
+        rootKey: input.rootKey ?? process.env.UNKEY_ROOT_KEY ?? undefined,
+        apiId: input.apiId ?? process.env.UNKEY_API_ID ?? undefined,
+        baseUrl: input.baseUrl ?? process.env.UNKEY_BASE_URL ?? DEFAULT_UNKEY_BASE_URL,
+    };
+}
+function resolveUnkeyPaths(paths = {}) {
+    const basePath = normalizePath(paths.basePath ?? "/api/unkey");
+    return {
+        create: normalizePath(paths.create ?? `${basePath}/create`),
+        verify: normalizePath(paths.verify ?? `${basePath}/verify`),
+        update: normalizePath(paths.update ?? `${basePath}/update`),
+        revoke: normalizePath(paths.revoke ?? `${basePath}/revoke`),
+        deleteKey: normalizePath(paths.deleteKey ?? `${basePath}/delete-key`),
+    };
+}
+function normalizePath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+}
+async function readJsonBody(request) {
+    const text = await request.text();
+    if (!text) {
+        return {};
+    }
+    return JSON.parse(text);
+}
+function ensureInternalServerCall(context) {
+    if (context.req.get(FARM_INTEGRATION_INTERNAL_DISPATCH_CONTEXT_KEY) === true) {
+        return undefined;
+    }
+    return Response.json({
+        error: "Not found",
+    }, {
+        status: 404,
+    });
+}
+async function verifyProtectedRequest(request, context, client, options = {}) {
+    const key = getApiKeyFromRequest(request, options.headers);
+    if (!key) {
+        return ((await options.onDenied?.(request, context, {
+            valid: false,
+            code: "MISSING_KEY",
+        })) ||
+            Response.json({
+                error: "Missing API key",
+                code: "MISSING_KEY",
+            }, {
+                status: 401,
+            }));
+    }
+    try {
+        const result = await client.verifyKey({
+            key,
+            permissions: options.permissions,
+            tags: resolveProtectionTags(request, context, options.tags),
+        });
+        if (result.valid) {
+            const contextKey = options.contextKey ?? "unkey";
+            context.req.set(contextKey, result, {
+                exposeToPage: options.exposeToPage,
+            });
+            context.req.set("apiKey", result, {
+                exposeToPage: options.exposeToPage,
+            });
+            if (result.keyId) {
+                context.req.set("apiKeyId", result.keyId, {
+                    exposeToPage: options.exposeToPage,
+                });
+            }
+            if (result.identity?.externalId) {
+                context.req.set("apiKeyOwnerId", result.identity.externalId, {
+                    exposeToPage: options.exposeToPage,
+                });
+            }
+            return options.onVerified?.(request, context, result);
+        }
+        const override = await options.onDenied?.(request, context, result);
+        if (override) {
+            return override;
+        }
+        return Response.json({
+            error: "Invalid API key",
+            code: result.code ?? "INVALID",
+        }, {
+            status: result.code === "RATE_LIMITED" ? 429 : 401,
+        });
+    }
+    catch {
+        const failure = {
+            valid: false,
+            code: "VERIFY_ERROR",
+        };
+        const override = await options.onDenied?.(request, context, failure);
+        if (override) {
+            return override;
+        }
+        return Response.json({
+            error: "API key verification failed",
+            code: failure.code,
+        }, {
+            status: 401,
+        });
+    }
+}
+function getApiKeyFromRequest(request, headers) {
+    const names = Array.isArray(headers)
+        ? headers
+        : headers
+            ? [headers]
+            : ["authorization", "x-api-key"];
+    for (const name of names) {
+        const value = request.headers.get(name);
+        if (!value) {
+            continue;
+        }
+        if (name.toLowerCase() === "authorization") {
+            const match = value.match(/^Bearer\s+(.+)$/i);
+            return (match?.[1] || value).trim();
+        }
+        return value.trim();
+    }
+    return undefined;
+}
+function resolveProtectionTags(request, context, tags) {
+    return typeof tags === "function" ? tags(request, context) : tags;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@farm.js/unkey",
+  "version": "0.1.0-beta.0",
+  "description": "Unkey integration for Farm.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/farming-labs/farm.js",
+    "directory": "packages/farm-unkey"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@farm.js/core": "0.1.0-beta.0",
+    "@farm.js/integration-utils": "0.1.0-beta.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "test": "echo 'No tests in this package'"
+  }
+}