@gatwech/auth 1.0.0-beta.18

package/dist/client-CNY0tn9g.d.mts

@@ -0,0 +1,628 @@
+import { t as InferOptionSchema } from "./plugins-hFZT3hmK.mjs";
+import * as better_call164 from "better-call";
+import * as z$1 from "zod";
+import { StringValue } from "ms";
+
+//#region src/plugins/device-authorization/schema.d.ts
+declare const schema: {
+  deviceCode: {
+    fields: {
+      deviceCode: {
+        type: "string";
+        required: true;
+      };
+      userCode: {
+        type: "string";
+        required: true;
+      };
+      userId: {
+        type: "string";
+        required: false;
+      };
+      expiresAt: {
+        type: "date";
+        required: true;
+      };
+      status: {
+        type: "string";
+        required: true;
+      };
+      lastPolledAt: {
+        type: "date";
+        required: false;
+      };
+      pollingInterval: {
+        type: "number";
+        required: false;
+      };
+      clientId: {
+        type: "string";
+        required: false;
+      };
+      scope: {
+        type: "string";
+        required: false;
+      };
+    };
+  };
+};
+//#endregion
+//#region src/plugins/device-authorization/index.d.ts
+declare const $deviceAuthorizationOptionsSchema: z$1.ZodObject<{
+  expiresIn: z$1.ZodDefault<z$1.ZodCustom<StringValue, StringValue>>;
+  interval: z$1.ZodDefault<z$1.ZodCustom<StringValue, StringValue>>;
+  deviceCodeLength: z$1.ZodDefault<z$1.ZodNumber>;
+  userCodeLength: z$1.ZodDefault<z$1.ZodNumber>;
+  generateDeviceCode: z$1.ZodOptional<z$1.ZodCustom<() => string | Promise<string>, () => string | Promise<string>>>;
+  generateUserCode: z$1.ZodOptional<z$1.ZodCustom<() => string | Promise<string>, () => string | Promise<string>>>;
+  validateClient: z$1.ZodOptional<z$1.ZodCustom<(clientId: string) => boolean | Promise<boolean>, (clientId: string) => boolean | Promise<boolean>>>;
+  onDeviceAuthRequest: z$1.ZodOptional<z$1.ZodCustom<(clientId: string, scope: string | undefined) => void | Promise<void>, (clientId: string, scope: string | undefined) => void | Promise<void>>>;
+  schema: z$1.ZodCustom<{
+    deviceCode?: {
+      modelName?: string | undefined;
+      fields?: {
+        deviceCode?: string | undefined;
+        userCode?: string | undefined;
+        userId?: string | undefined;
+        expiresAt?: string | undefined;
+        status?: string | undefined;
+        lastPolledAt?: string | undefined;
+        pollingInterval?: string | undefined;
+        clientId?: string | undefined;
+        scope?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }, {
+    deviceCode?: {
+      modelName?: string | undefined;
+      fields?: {
+        deviceCode?: string | undefined;
+        userCode?: string | undefined;
+        userId?: string | undefined;
+        expiresAt?: string | undefined;
+        status?: string | undefined;
+        lastPolledAt?: string | undefined;
+        pollingInterval?: string | undefined;
+        clientId?: string | undefined;
+        scope?: string | undefined;
+      } | undefined;
+    } | undefined;
+  }>;
+}, z$1.core.$strip>;
+/**
+ * @see {$deviceAuthorizationOptionsSchema}
+ */
+type DeviceAuthorizationOptions = {
+  expiresIn: StringValue;
+  interval: StringValue;
+  deviceCodeLength: number;
+  userCodeLength: number;
+  generateDeviceCode?: (() => string | Promise<string>) | undefined;
+  generateUserCode?: (() => string | Promise<string>) | undefined;
+  validateClient?: ((clientId: string) => boolean | Promise<boolean>) | undefined;
+  onDeviceAuthRequest?: (clientId: string, scope: string | undefined) => void | Promise<void>;
+  schema?: InferOptionSchema<typeof schema> | undefined;
+};
+declare const deviceAuthorization: (options?: Partial<DeviceAuthorizationOptions>) => {
+  id: "device-authorization";
+  schema: {
+    deviceCode: {
+      fields: {
+        deviceCode: {
+          type: "string";
+          required: true;
+        };
+        userCode: {
+          type: "string";
+          required: true;
+        };
+        userId: {
+          type: "string";
+          required: false;
+        };
+        expiresAt: {
+          type: "date";
+          required: true;
+        };
+        status: {
+          type: "string";
+          required: true;
+        };
+        lastPolledAt: {
+          type: "date";
+          required: false;
+        };
+        pollingInterval: {
+          type: "number";
+          required: false;
+        };
+        clientId: {
+          type: "string";
+          required: false;
+        };
+        scope: {
+          type: "string";
+          required: false;
+        };
+      };
+    };
+  };
+  endpoints: {
+    deviceCode: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          client_id: string;
+          scope?: string | undefined;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call164.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          device_code: string;
+          user_code: string;
+          verification_uri: string;
+          verification_uri_complete: string;
+          expires_in: number;
+          interval: number;
+        };
+      } : {
+        device_code: string;
+        user_code: string;
+        verification_uri: string;
+        verification_uri_complete: string;
+        expires_in: number;
+        interval: number;
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          client_id: z$1.ZodString;
+          scope: z$1.ZodOptional<z$1.ZodString>;
+        }, z$1.core.$strip>;
+        error: z$1.ZodObject<{
+          error: z$1.ZodEnum<{
+            invalid_request: "invalid_request";
+            invalid_client: "invalid_client";
+          }>;
+          error_description: z$1.ZodString;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        device_code: {
+                          type: string;
+                          description: string;
+                        };
+                        user_code: {
+                          type: string;
+                          description: string;
+                        };
+                        verification_uri: {
+                          type: string;
+                          description: string;
+                        };
+                        verification_uri_complete: {
+                          type: string;
+                          description: string;
+                        };
+                        expires_in: {
+                          type: string;
+                          description: string;
+                        };
+                        interval: {
+                          type: string;
+                          description: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+              400: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        error: {
+                          type: string;
+                          enum: string[];
+                        };
+                        error_description: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/device/code";
+    };
+    deviceToken: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code";
+          device_code: string;
+          client_id: string;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call164.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          access_token: string;
+          token_type: string;
+          expires_in: number;
+          scope: string;
+        };
+      } : {
+        access_token: string;
+        token_type: string;
+        expires_in: number;
+        scope: string;
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          grant_type: z$1.ZodLiteral<"urn:ietf:params:oauth:grant-type:device_code">;
+          device_code: z$1.ZodString;
+          client_id: z$1.ZodString;
+        }, z$1.core.$strip>;
+        error: z$1.ZodObject<{
+          error: z$1.ZodEnum<{
+            invalid_request: "invalid_request";
+            authorization_pending: "authorization_pending";
+            slow_down: "slow_down";
+            expired_token: "expired_token";
+            access_denied: "access_denied";
+            invalid_grant: "invalid_grant";
+          }>;
+          error_description: z$1.ZodString;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        session: {
+                          $ref: string;
+                        };
+                        user: {
+                          $ref: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+              400: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        error: {
+                          type: string;
+                          enum: string[];
+                        };
+                        error_description: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/device/token";
+    };
+    deviceVerify: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body?: undefined;
+      } & {
+        method?: "GET" | undefined;
+      } & {
+        query: {
+          user_code: string;
+        };
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call164.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          user_code: string;
+          status: string;
+        };
+      } : {
+        user_code: string;
+        status: string;
+      }>;
+      options: {
+        method: "GET";
+        query: z$1.ZodObject<{
+          user_code: z$1.ZodString;
+        }, z$1.core.$strip>;
+        error: z$1.ZodObject<{
+          error: z$1.ZodEnum<{
+            invalid_request: "invalid_request";
+          }>;
+          error_description: z$1.ZodString;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        user_code: {
+                          type: string;
+                          description: string;
+                        };
+                        status: {
+                          type: string;
+                          enum: string[];
+                          description: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/device";
+    };
+    deviceApprove: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          userCode: string;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call164.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          success: boolean;
+        };
+      } : {
+        success: boolean;
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          userCode: z$1.ZodString;
+        }, z$1.core.$strip>;
+        error: z$1.ZodObject<{
+          error: z$1.ZodEnum<{
+            invalid_request: "invalid_request";
+            expired_token: "expired_token";
+            device_code_already_processed: "device_code_already_processed";
+          }>;
+          error_description: z$1.ZodString;
+        }, z$1.core.$strip>;
+        requireHeaders: true;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/device/approve";
+    };
+    deviceDeny: {
+      <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+        body: {
+          userCode: string;
+        };
+      } & {
+        method?: "POST" | undefined;
+      } & {
+        query?: Record<string, any> | undefined;
+      } & {
+        params?: Record<string, any>;
+      } & {
+        request?: Request;
+      } & {
+        headers?: HeadersInit;
+      } & {
+        asResponse?: boolean;
+        returnHeaders?: boolean;
+        use?: better_call164.Middleware[];
+        path?: string;
+      } & {
+        asResponse?: AsResponse | undefined;
+        returnHeaders?: ReturnHeaders | undefined;
+      }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+        headers: Headers;
+        response: {
+          success: boolean;
+        };
+      } : {
+        success: boolean;
+      }>;
+      options: {
+        method: "POST";
+        body: z$1.ZodObject<{
+          userCode: z$1.ZodString;
+        }, z$1.core.$strip>;
+        error: z$1.ZodObject<{
+          error: z$1.ZodEnum<{
+            invalid_request: "invalid_request";
+            expired_token: "expired_token";
+          }>;
+          error_description: z$1.ZodString;
+        }, z$1.core.$strip>;
+        metadata: {
+          openapi: {
+            description: string;
+            responses: {
+              200: {
+                description: string;
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object";
+                      properties: {
+                        success: {
+                          type: string;
+                        };
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      } & {
+        use: any[];
+      };
+      path: "/device/deny";
+    };
+  };
+  $ERROR_CODES: {
+    readonly INVALID_DEVICE_CODE: "Invalid device code";
+    readonly EXPIRED_DEVICE_CODE: "Device code has expired";
+    readonly EXPIRED_USER_CODE: "User code has expired";
+    readonly AUTHORIZATION_PENDING: "Authorization pending";
+    readonly ACCESS_DENIED: "Access denied";
+    readonly INVALID_USER_CODE: "Invalid user code";
+    readonly DEVICE_CODE_ALREADY_PROCESSED: "Device code already processed";
+    readonly POLLING_TOO_FREQUENTLY: "Polling too frequently";
+    readonly USER_NOT_FOUND: "User not found";
+    readonly FAILED_TO_CREATE_SESSION: "Failed to create session";
+    readonly INVALID_DEVICE_CODE_STATUS: "Invalid device code status";
+    readonly AUTHENTICATION_REQUIRED: "Authentication required";
+  };
+};
+//#endregion
+//#region src/plugins/device-authorization/client.d.ts
+declare const deviceAuthorizationClient: () => {
+  id: "device-authorization";
+  $InferServerPlugin: ReturnType<typeof deviceAuthorization>;
+  pathMethods: {
+    "/device/code": "POST";
+    "/device/token": "POST";
+    "/device": "GET";
+    "/device/approve": "POST";
+    "/device/deny": "POST";
+  };
+};
+//#endregion
+export { deviceAuthorization as i, $deviceAuthorizationOptionsSchema as n, DeviceAuthorizationOptions as r, deviceAuthorizationClient as t };

package/dist/client-CygJhqeB.mjs

@@ -0,0 +1,29 @@
+//#region src/plugins/two-factor/client.ts
+const twoFactorClient = (options) => {
+	return {
+		id: "two-factor",
+		$InferServerPlugin: {},
+		atomListeners: [{
+			matcher: (path) => path.startsWith("/two-factor/"),
+			signal: "$sessionSignal"
+		}],
+		pathMethods: {
+			"/two-factor/disable": "POST",
+			"/two-factor/enable": "POST",
+			"/two-factor/send-otp": "POST",
+			"/two-factor/generate-backup-codes": "POST"
+		},
+		fetchPlugins: [{
+			id: "two-factor",
+			name: "two-factor",
+			hooks: { async onSuccess(context) {
+				if (context.data?.twoFactorRedirect) {
+					if (options?.onTwoFactorRedirect) await options.onTwoFactorRedirect();
+				}
+			} }
+		}]
+	};
+};
+
+//#endregion
+export { twoFactorClient as t };

package/dist/client-WiN43tAS.mjs

@@ -0,0 +1,17 @@
+//#region src/plugins/device-authorization/client.ts
+const deviceAuthorizationClient = () => {
+	return {
+		id: "device-authorization",
+		$InferServerPlugin: {},
+		pathMethods: {
+			"/device/code": "POST",
+			"/device/token": "POST",
+			"/device": "GET",
+			"/device/approve": "POST",
+			"/device/deny": "POST"
+		}
+	};
+};
+
+//#endregion
+export { deviceAuthorizationClient as t };

package/dist/client-aExCkfwm.mjs

@@ -0,0 +1,30 @@
+import { t as capitalizeFirstLetter } from "./misc-beA1w3XV.mjs";
+import { n as getClientConfig, t as createDynamicPathProxy } from "./proxy-CL9PZXJA.mjs";
+
+//#region src/client/vanilla.ts
+function createAuthClient(options) {
+	const { pluginPathMethods, pluginsActions, pluginsAtoms, $fetch, atomListeners, $store } = getClientConfig(options);
+	let resolvedHooks = {};
+	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[`use${capitalizeFirstLetter(key)}`] = value;
+	return createDynamicPathProxy({
+		...pluginsActions,
+		...resolvedHooks,
+		$fetch,
+		$store
+	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+}
+
+//#endregion
+//#region src/client/index.ts
+const InferPlugin = () => {
+	return {
+		id: "infer-server-plugin",
+		$InferServerPlugin: {}
+	};
+};
+function InferAuth() {
+	return {};
+}
+
+//#endregion
+export { InferPlugin as n, createAuthClient as r, InferAuth as t };

package/dist/cookies/index.d.mts

@@ -0,0 +1,7 @@
+import "../helper-tmxW3BHj.mjs";
+import "../index-Cxi7TbLE.mjs";
+import "../types-B1OL7hyf.mjs";
+import "../index-65G5U5DB-DSdjzreF.mjs";
+import "../plugins-hFZT3hmK.mjs";
+import { a as getCookies, c as setCookieCache, d as getChunkedCookie, f as parseSetCookieHeader, i as getCookieCache, l as setSessionCookie, n as createCookieGetter, o as getSessionCookie, p as setCookieToHeader, r as deleteSessionCookie, s as parseCookies, t as EligibleCookies, u as createSessionStore } from "../index-DR0xXno9.mjs";
+export { EligibleCookies, createCookieGetter, createSessionStore, deleteSessionCookie, getChunkedCookie, getCookieCache, getCookies, getSessionCookie, parseCookies, parseSetCookieHeader, setCookieCache, setCookieToHeader, setSessionCookie };