@aura-stack/auth 0.1.0-rc.9 → 0.2.0-rc.1

package/dist/schemas.cjs

@@ -1,105 +1,111 @@
-"use strict"
-var __defProp = Object.defineProperty
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor
-var __getOwnPropNames = Object.getOwnPropertyNames
-var __hasOwnProp = Object.prototype.hasOwnProperty
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, { get: all[name], enumerable: true })
-}
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
-    if ((from && typeof from === "object") || typeof from === "function") {
-        for (let key of __getOwnPropNames(from))
-            if (!__hasOwnProp.call(to, key) && key !== except)
-                __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable })
-    }
-    return to
-}
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod)
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/schemas.ts
-var schemas_exports = {}
+var schemas_exports = {};
 __export(schemas_exports, {
-    OAuthAccessToken: () => OAuthAccessToken,
-    OAuthAccessTokenErrorResponse: () => OAuthAccessTokenErrorResponse,
-    OAuthAccessTokenResponse: () => OAuthAccessTokenResponse,
-    OAuthAuthorization: () => OAuthAuthorization,
-    OAuthAuthorizationErrorResponse: () => OAuthAuthorizationErrorResponse,
-    OAuthAuthorizationResponse: () => OAuthAuthorizationResponse,
-    OAuthErrorResponse: () => OAuthErrorResponse,
-    OAuthProviderConfigSchema: () => OAuthProviderConfigSchema,
-})
-module.exports = __toCommonJS(schemas_exports)
-var import_v4 = require("zod/v4")
-var OAuthProviderConfigSchema = (0, import_v4.object)({
-    authorizeURL: (0, import_v4.url)(),
-    accessToken: (0, import_v4.url)(),
-    scope: (0, import_v4.string)().optional(),
-    userInfo: (0, import_v4.url)(),
-    responseType: (0, import_v4.enum)(["code", "token", "id_token"]),
-    clientId: (0, import_v4.string)(),
-    clientSecret: (0, import_v4.string)(),
-})
+  OAuthAccessToken: () => OAuthAccessToken,
+  OAuthAccessTokenErrorResponse: () => OAuthAccessTokenErrorResponse,
+  OAuthAccessTokenResponse: () => OAuthAccessTokenResponse,
+  OAuthAuthorization: () => OAuthAuthorization,
+  OAuthAuthorizationErrorResponse: () => OAuthAuthorizationErrorResponse,
+  OAuthAuthorizationResponse: () => OAuthAuthorizationResponse,
+  OAuthEnvSchema: () => OAuthEnvSchema,
+  OAuthErrorResponse: () => OAuthErrorResponse,
+  OAuthProviderConfigSchema: () => OAuthProviderConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var OAuthProviderConfigSchema = (0, import_zod.object)({
+  authorizeURL: (0, import_zod.string)().url(),
+  accessToken: (0, import_zod.string)().url(),
+  scope: (0, import_zod.string)().optional(),
+  userInfo: (0, import_zod.string)().url(),
+  responseType: (0, import_zod.enum)(["code", "token", "id_token"]),
+  clientId: (0, import_zod.string)(),
+  clientSecret: (0, import_zod.string)()
+});
 var OAuthAuthorization = OAuthProviderConfigSchema.extend({
-    redirectURI: (0, import_v4.string)(),
-    state: (0, import_v4.string)(),
-    codeChallenge: (0, import_v4.string)(),
-    codeChallengeMethod: (0, import_v4.enum)(["plain", "S256"]),
-})
-var OAuthAuthorizationResponse = (0, import_v4.object)({
-    state: (0, import_v4.string)(),
-    code: (0, import_v4.string)(),
-})
-var OAuthAuthorizationErrorResponse = (0, import_v4.object)({
-    error: (0, import_v4.enum)([
-        "invalid_request",
-        "unauthorized_client",
-        "access_denied",
-        "unsupported_response_type",
-        "invalid_scope",
-        "server_error",
-        "temporarily_unavailable",
-    ]),
-    error_description: (0, import_v4.string)().optional(),
-    error_uri: (0, import_v4.string)().optional(),
-    state: (0, import_v4.string)(),
-})
+  redirectURI: (0, import_zod.string)(),
+  state: (0, import_zod.string)(),
+  codeChallenge: (0, import_zod.string)(),
+  codeChallengeMethod: (0, import_zod.enum)(["plain", "S256"])
+});
+var OAuthAuthorizationResponse = (0, import_zod.object)({
+  state: (0, import_zod.string)({ message: "Missing state parameter in the OAuth authorization response." }),
+  code: (0, import_zod.string)({ message: "Missing code parameter in the OAuth authorization response." })
+});
+var OAuthAuthorizationErrorResponse = (0, import_zod.object)({
+  error: (0, import_zod.enum)([
+    "invalid_request",
+    "unauthorized_client",
+    "access_denied",
+    "unsupported_response_type",
+    "invalid_scope",
+    "server_error",
+    "temporarily_unavailable"
+  ]),
+  error_description: (0, import_zod.string)().optional(),
+  error_uri: (0, import_zod.string)().optional(),
+  state: (0, import_zod.string)()
+});
 var OAuthAccessToken = OAuthProviderConfigSchema.extend({
-    redirectURI: (0, import_v4.string)(),
-    code: (0, import_v4.string)(),
-    codeVerifier: (0, import_v4.string)().min(43).max(128),
-})
-var OAuthAccessTokenResponse = (0, import_v4.object)({
-    access_token: (0, import_v4.string)(),
-    token_type: (0, import_v4.string)(),
-    expires_in: (0, import_v4.number)().optional(),
-    refresh_token: (0, import_v4.string)().optional(),
-    scope: (0, import_v4.string)().optional(),
-})
-var OAuthAccessTokenErrorResponse = (0, import_v4.object)({
-    error: (0, import_v4.enum)([
-        "invalid_request",
-        "invalid_client",
-        "invalid_grant",
-        "unauthorized_client",
-        "unsupported_grant_type",
-        "invalid_scope",
-    ]),
-    error_description: (0, import_v4.string)().optional(),
-    error_uri: (0, import_v4.string)().optional(),
-})
-var OAuthErrorResponse = (0, import_v4.object)({
-    error: (0, import_v4.string)(),
-    error_description: (0, import_v4.string)().optional(),
-})
+  redirectURI: (0, import_zod.string)(),
+  code: (0, import_zod.string)(),
+  codeVerifier: (0, import_zod.string)().min(43).max(128)
+});
+var OAuthAccessTokenResponse = (0, import_zod.object)({
+  access_token: (0, import_zod.string)(),
+  token_type: (0, import_zod.string)().optional(),
+  expires_in: (0, import_zod.number)().optional(),
+  refresh_token: (0, import_zod.string)().optional(),
+  scope: (0, import_zod.string)().optional().or((0, import_zod.null)())
+});
+var OAuthAccessTokenErrorResponse = (0, import_zod.object)({
+  error: (0, import_zod.enum)([
+    "invalid_request",
+    "invalid_client",
+    "invalid_grant",
+    "unauthorized_client",
+    "unsupported_grant_type",
+    "invalid_scope"
+  ]),
+  error_description: (0, import_zod.string)().optional(),
+  error_uri: (0, import_zod.string)().optional()
+});
+var OAuthErrorResponse = (0, import_zod.object)({
+  error: (0, import_zod.string)(),
+  error_description: (0, import_zod.string)().optional()
+});
+var OAuthEnvSchema = (0, import_zod.object)({
+  clientId: import_zod.z.string().min(1, "OAuth Client ID is required in the environment variables."),
+  clientSecret: import_zod.z.string().min(1, "OAuth Client Secret is required in the environment variables.")
+});
 // Annotate the CommonJS export names for ESM import in node:
-0 &&
-    (module.exports = {
-        OAuthAccessToken,
-        OAuthAccessTokenErrorResponse,
-        OAuthAccessTokenResponse,
-        OAuthAuthorization,
-        OAuthAuthorizationErrorResponse,
-        OAuthAuthorizationResponse,
-        OAuthErrorResponse,
-        OAuthProviderConfigSchema,
-    })
+0 && (module.exports = {
+  OAuthAccessToken,
+  OAuthAccessTokenErrorResponse,
+  OAuthAccessTokenResponse,
+  OAuthAuthorization,
+  OAuthAuthorizationErrorResponse,
+  OAuthAuthorizationResponse,
+  OAuthEnvSchema,
+  OAuthErrorResponse,
+  OAuthProviderConfigSchema
+});

package/dist/schemas.d.ts

@@ -1,163 +1,133 @@
-import * as zod_v4_core from "zod/v4/core"
-import * as zod_v4 from "zod/v4"
+import { z } from 'zod';
 
 /**
  * Schema for OAuth Provider Configuration
  */
-declare const OAuthProviderConfigSchema: zod_v4.ZodObject<
-    {
-        authorizeURL: zod_v4.ZodURL
-        accessToken: zod_v4.ZodURL
-        scope: zod_v4.ZodOptional<zod_v4.ZodString>
-        userInfo: zod_v4.ZodURL
-        responseType: zod_v4.ZodEnum<{
-            token: "token"
-            code: "code"
-            id_token: "id_token"
-        }>
-        clientId: zod_v4.ZodString
-        clientSecret: zod_v4.ZodString
-    },
-    zod_v4_core.$strip
->
+declare const OAuthProviderConfigSchema: z.ZodObject<{
+    authorizeURL: z.ZodString;
+    accessToken: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    userInfo: z.ZodString;
+    responseType: z.ZodEnum<{
+        token: "token";
+        code: "code";
+        id_token: "id_token";
+    }>;
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+}, z.core.$strip>;
 /**
  * Schema used to create the authorization URL for the OAuth flow and verify the
  * OAuth configuration.
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.1
  */
-declare const OAuthAuthorization: zod_v4.ZodObject<
-    {
-        authorizeURL: zod_v4.ZodURL
-        accessToken: zod_v4.ZodURL
-        scope: zod_v4.ZodOptional<zod_v4.ZodString>
-        userInfo: zod_v4.ZodURL
-        responseType: zod_v4.ZodEnum<{
-            token: "token"
-            code: "code"
-            id_token: "id_token"
-        }>
-        clientId: zod_v4.ZodString
-        clientSecret: zod_v4.ZodString
-        redirectURI: zod_v4.ZodString
-        state: zod_v4.ZodString
-        codeChallenge: zod_v4.ZodString
-        codeChallengeMethod: zod_v4.ZodEnum<{
-            S256: "S256"
-            plain: "plain"
-        }>
-    },
-    zod_v4_core.$strip
->
+declare const OAuthAuthorization: z.ZodObject<{
+    authorizeURL: z.ZodString;
+    accessToken: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    userInfo: z.ZodString;
+    responseType: z.ZodEnum<{
+        token: "token";
+        code: "code";
+        id_token: "id_token";
+    }>;
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+    redirectURI: z.ZodString;
+    state: z.ZodString;
+    codeChallenge: z.ZodString;
+    codeChallengeMethod: z.ZodEnum<{
+        plain: "plain";
+        S256: "S256";
+    }>;
+}, z.core.$strip>;
 /**
  * Schema used in the callback action to validate the authorization response when the resource owner
  * has granted.
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2
  */
-declare const OAuthAuthorizationResponse: zod_v4.ZodObject<
-    {
-        state: zod_v4.ZodString
-        code: zod_v4.ZodString
-    },
-    zod_v4_core.$strip
->
+declare const OAuthAuthorizationResponse: z.ZodObject<{
+    state: z.ZodString;
+    code: z.ZodString;
+}, z.core.$strip>;
 /**
  * Schema used in the callback action to validate the authorization error response when the resource owner
  * has denied the authorization request.
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2.1
  */
-declare const OAuthAuthorizationErrorResponse: zod_v4.ZodObject<
-    {
-        error: zod_v4.ZodEnum<{
-            invalid_request: "invalid_request"
-            unauthorized_client: "unauthorized_client"
-            access_denied: "access_denied"
-            unsupported_response_type: "unsupported_response_type"
-            invalid_scope: "invalid_scope"
-            server_error: "server_error"
-            temporarily_unavailable: "temporarily_unavailable"
-        }>
-        error_description: zod_v4.ZodOptional<zod_v4.ZodString>
-        error_uri: zod_v4.ZodOptional<zod_v4.ZodString>
-        state: zod_v4.ZodString
-    },
-    zod_v4_core.$strip
->
+declare const OAuthAuthorizationErrorResponse: z.ZodObject<{
+    error: z.ZodEnum<{
+        invalid_request: "invalid_request";
+        unauthorized_client: "unauthorized_client";
+        access_denied: "access_denied";
+        unsupported_response_type: "unsupported_response_type";
+        invalid_scope: "invalid_scope";
+        server_error: "server_error";
+        temporarily_unavailable: "temporarily_unavailable";
+    }>;
+    error_description: z.ZodOptional<z.ZodString>;
+    error_uri: z.ZodOptional<z.ZodString>;
+    state: z.ZodString;
+}, z.core.$strip>;
 /**
  * Schema for OAuth Access Token Request and OAuth Configuration
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.3
  */
-declare const OAuthAccessToken: zod_v4.ZodObject<
-    {
-        authorizeURL: zod_v4.ZodURL
-        accessToken: zod_v4.ZodURL
-        scope: zod_v4.ZodOptional<zod_v4.ZodString>
-        userInfo: zod_v4.ZodURL
-        responseType: zod_v4.ZodEnum<{
-            token: "token"
-            code: "code"
-            id_token: "id_token"
-        }>
-        clientId: zod_v4.ZodString
-        clientSecret: zod_v4.ZodString
-        redirectURI: zod_v4.ZodString
-        code: zod_v4.ZodString
-        codeVerifier: zod_v4.ZodString
-    },
-    zod_v4_core.$strip
->
+declare const OAuthAccessToken: z.ZodObject<{
+    authorizeURL: z.ZodString;
+    accessToken: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    userInfo: z.ZodString;
+    responseType: z.ZodEnum<{
+        token: "token";
+        code: "code";
+        id_token: "id_token";
+    }>;
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+    redirectURI: z.ZodString;
+    code: z.ZodString;
+    codeVerifier: z.ZodString;
+}, z.core.$strip>;
 /**
  * Schema for OAuth Access Token Response
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-5.1
  * @see https://datatracker.ietf.org/doc/html/rfc7636#section-4
  */
-declare const OAuthAccessTokenResponse: zod_v4.ZodObject<
-    {
-        access_token: zod_v4.ZodString
-        token_type: zod_v4.ZodString
-        expires_in: zod_v4.ZodOptional<zod_v4.ZodNumber>
-        refresh_token: zod_v4.ZodOptional<zod_v4.ZodString>
-        scope: zod_v4.ZodOptional<zod_v4.ZodString>
-    },
-    zod_v4_core.$strip
->
+declare const OAuthAccessTokenResponse: z.ZodObject<{
+    access_token: z.ZodString;
+    token_type: z.ZodOptional<z.ZodString>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    scope: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodNull]>;
+}, z.core.$strip>;
 /**
  * Schema for OAuth Access Token Error Response
  * @see https://datatracker.ietf.org/doc/html/rfc6749#section-5.2
  */
-declare const OAuthAccessTokenErrorResponse: zod_v4.ZodObject<
-    {
-        error: zod_v4.ZodEnum<{
-            invalid_request: "invalid_request"
-            unauthorized_client: "unauthorized_client"
-            invalid_scope: "invalid_scope"
-            invalid_client: "invalid_client"
-            invalid_grant: "invalid_grant"
-            unsupported_grant_type: "unsupported_grant_type"
-        }>
-        error_description: zod_v4.ZodOptional<zod_v4.ZodString>
-        error_uri: zod_v4.ZodOptional<zod_v4.ZodString>
-    },
-    zod_v4_core.$strip
->
+declare const OAuthAccessTokenErrorResponse: z.ZodObject<{
+    error: z.ZodEnum<{
+        invalid_request: "invalid_request";
+        unauthorized_client: "unauthorized_client";
+        invalid_scope: "invalid_scope";
+        invalid_client: "invalid_client";
+        invalid_grant: "invalid_grant";
+        unsupported_grant_type: "unsupported_grant_type";
+    }>;
+    error_description: z.ZodOptional<z.ZodString>;
+    error_uri: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * @todo: verify if this schema is still needed
  * @deprecated
  */
-declare const OAuthErrorResponse: zod_v4.ZodObject<
-    {
-        error: zod_v4.ZodString
-        error_description: zod_v4.ZodOptional<zod_v4.ZodString>
-    },
-    zod_v4_core.$strip
->
+declare const OAuthErrorResponse: z.ZodObject<{
+    error: z.ZodString;
+    error_description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const OAuthEnvSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+}, z.core.$strip>;
 
-export {
-    OAuthAccessToken,
-    OAuthAccessTokenErrorResponse,
-    OAuthAccessTokenResponse,
-    OAuthAuthorization,
-    OAuthAuthorizationErrorResponse,
-    OAuthAuthorizationResponse,
-    OAuthErrorResponse,
-    OAuthProviderConfigSchema,
-}
+export { OAuthAccessToken, OAuthAccessTokenErrorResponse, OAuthAccessTokenResponse, OAuthAuthorization, OAuthAuthorizationErrorResponse, OAuthAuthorizationResponse, OAuthEnvSchema, OAuthErrorResponse, OAuthProviderConfigSchema };

package/dist/schemas.js

@@ -1,20 +1,22 @@
 import {
-    OAuthAccessToken,
-    OAuthAccessTokenErrorResponse,
-    OAuthAccessTokenResponse,
-    OAuthAuthorization,
-    OAuthAuthorizationErrorResponse,
-    OAuthAuthorizationResponse,
-    OAuthErrorResponse,
-    OAuthProviderConfigSchema,
-} from "./chunk-HMRKN75I.js"
+  OAuthAccessToken,
+  OAuthAccessTokenErrorResponse,
+  OAuthAccessTokenResponse,
+  OAuthAuthorization,
+  OAuthAuthorizationErrorResponse,
+  OAuthAuthorizationResponse,
+  OAuthEnvSchema,
+  OAuthErrorResponse,
+  OAuthProviderConfigSchema
+} from "./chunk-YRCB5FLE.js";
 export {
-    OAuthAccessToken,
-    OAuthAccessTokenErrorResponse,
-    OAuthAccessTokenResponse,
-    OAuthAuthorization,
-    OAuthAuthorizationErrorResponse,
-    OAuthAuthorizationResponse,
-    OAuthErrorResponse,
-    OAuthProviderConfigSchema,
-}
+  OAuthAccessToken,
+  OAuthAccessTokenErrorResponse,
+  OAuthAccessTokenResponse,
+  OAuthAuthorization,
+  OAuthAuthorizationErrorResponse,
+  OAuthAuthorizationResponse,
+  OAuthEnvSchema,
+  OAuthErrorResponse,
+  OAuthProviderConfigSchema
+};