@jskit-ai/auth-core 0.1.54 → 0.1.56

package/src/shared/commands/authLoginOAuthCompleteCommand.js

@@ -1,12 +1,12 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
-  authAccessTokenValidator,
-  authRecoveryTokenValidator,
-  authRefreshTokenValidator,
+  authAccessTokenFieldDefinition,
+  authRecoveryTokenFieldDefinition,
+  authRefreshTokenFieldDefinition,
   createCommandMessages,
-  oauthCompleteResponseValidator,
-  oauthProviderValidator
+  oauthCompleteOutputValidator,
+  oauthProviderFieldDefinition
 } from "./authCommandValidators.js";
 
 const AUTH_LOGIN_OAUTH_COMPLETE_MESSAGES = createCommandMessages({
@@ -27,41 +27,36 @@ const AUTH_LOGIN_OAUTH_COMPLETE_MESSAGES = createCommandMessages({
   }
 });
 
-const authLoginOAuthCompleteBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      provider: Type.Optional(oauthProviderValidator.schema),
-      code: Type.Optional(authRecoveryTokenValidator.schema),
-      accessToken: Type.Optional(authAccessTokenValidator.schema),
-      refreshToken: Type.Optional(authRefreshTokenValidator.schema),
-      error: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),
-      errorDescription: Type.Optional(Type.String({ minLength: 1, maxLength: 1024 })),
-      error_code: Type.Optional(Type.String({ minLength: 1, maxLength: 128 })),
-      error_description: Type.Optional(Type.String({ minLength: 1, maxLength: 1024 }))
-    },
-    {
-      additionalProperties: false
-    }
-  ),
-  normalize: normalizeObjectInput,
+const authLoginOAuthCompleteBodyValidator = deepFreeze({
+  schema: createSchema({
+    provider: { ...oauthProviderFieldDefinition, required: false },
+    code: { ...authRecoveryTokenFieldDefinition, required: false },
+    accessToken: { ...authAccessTokenFieldDefinition, required: false },
+    refreshToken: { ...authRefreshTokenFieldDefinition, required: false },
+    error: { type: "string", required: false, minLength: 1, maxLength: 128 },
+    errorDescription: { type: "string", required: false, minLength: 1, maxLength: 1024 },
+    error_code: { type: "string", required: false, minLength: 1, maxLength: 128 },
+    error_description: { type: "string", required: false, minLength: 1, maxLength: 1024 }
+  }),
+  mode: "patch",
   messages: AUTH_LOGIN_OAUTH_COMPLETE_MESSAGES
 });
 
-const authLoginOAuthCompleteCommand = Object.freeze({
+const authLoginOAuthCompleteCommand = deepFreeze({
   command: "auth.login.oauth.complete",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    bodyValidator: authLoginOAuthCompleteBodyValidator,
-    responseValidator: oauthCompleteResponseValidator,
+    body: authLoginOAuthCompleteBodyValidator,
+    response: oauthCompleteOutputValidator,
     messages: AUTH_LOGIN_OAUTH_COMPLETE_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze(["auth.session.read"])
-  })
+    invalidates: ["auth.session.read"]
+  }
 });
 
 export {
   authLoginOAuthCompleteBodyValidator,
-  oauthCompleteResponseValidator,
+  oauthCompleteOutputValidator,
   AUTH_LOGIN_OAUTH_COMPLETE_MESSAGES,
   authLoginOAuthCompleteCommand
 };

package/src/shared/commands/authLoginOAuthStartCommand.js

@@ -1,9 +1,9 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
   createCommandMessages,
-  oauthProviderValidator,
-  oauthReturnToValidator
+  oauthProviderFieldDefinition,
+  oauthReturnToFieldDefinition
 } from "./authCommandValidators.js";
 
 const AUTH_LOGIN_OAUTH_START_MESSAGES = createCommandMessages({
@@ -20,53 +20,48 @@ const AUTH_LOGIN_OAUTH_START_MESSAGES = createCommandMessages({
   }
 });
 
-const authLoginOAuthStartParamsValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      provider: oauthProviderValidator.schema
-    },
-    {
-      additionalProperties: false
-    }
-  ),
-  normalize: normalizeObjectInput,
+const authLoginOAuthStartParamsValidator = deepFreeze({
+  schema: createSchema({
+    provider: { ...oauthProviderFieldDefinition, required: true }
+  }),
+  mode: "patch",
   messages: AUTH_LOGIN_OAUTH_START_MESSAGES
 });
 
-const authLoginOAuthStartQueryValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      returnTo: Type.Optional(oauthReturnToValidator.schema)
-    },
-    {
-      additionalProperties: false
-    }
-  ),
-  normalize: normalizeObjectInput,
+const authLoginOAuthStartQueryValidator = deepFreeze({
+  schema: createSchema({
+    returnTo: { ...oauthReturnToFieldDefinition, required: false }
+  }),
+  mode: "patch",
   messages: AUTH_LOGIN_OAUTH_START_MESSAGES
 });
 
-const authLoginOAuthStartResponseValidator = Object.freeze({
-  schema: Type.Unknown()
+const authLoginOAuthStartOutputValidator = deepFreeze({
+  schema: createSchema({
+    provider: { ...oauthProviderFieldDefinition, required: true },
+    returnTo: { ...oauthReturnToFieldDefinition, required: true },
+    url: { type: "string", required: true, minLength: 1, maxLength: 4096 }
+  }),
+  mode: "replace"
 });
 
-const authLoginOAuthStartCommand = Object.freeze({
+const authLoginOAuthStartCommand = deepFreeze({
   command: "auth.login.oauth.start",
-  operation: Object.freeze({
+  operation: {
     method: "GET",
-    paramsValidator: authLoginOAuthStartParamsValidator,
-    queryValidator: authLoginOAuthStartQueryValidator,
-    responseValidator: authLoginOAuthStartResponseValidator,
+    params: authLoginOAuthStartParamsValidator,
+    query: authLoginOAuthStartQueryValidator,
+    response: authLoginOAuthStartOutputValidator,
     messages: AUTH_LOGIN_OAUTH_START_MESSAGES,
     idempotent: true,
-    invalidates: Object.freeze([])
-  })
+    invalidates: []
+  }
 });
 
 export {
   authLoginOAuthStartParamsValidator,
   authLoginOAuthStartQueryValidator,
-  authLoginOAuthStartResponseValidator,
+  authLoginOAuthStartOutputValidator,
   AUTH_LOGIN_OAUTH_START_MESSAGES,
   authLoginOAuthStartCommand
 };

package/src/shared/commands/authLoginOtpRequestCommand.js

@@ -1,10 +1,10 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
-  authEmailValidator,
+  authEmailFieldDefinition,
   createCommandMessages,
-  oauthReturnToValidator,
-  okMessageResponseValidator
+  oauthReturnToFieldDefinition,
+  okMessageOutputValidator
 } from "./authCommandValidators.js";
 
 const AUTH_LOGIN_OTP_REQUEST_MESSAGES = createCommandMessages({
@@ -22,35 +22,30 @@ const AUTH_LOGIN_OTP_REQUEST_MESSAGES = createCommandMessages({
   }
 });
 
-const authLoginOtpRequestBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      email: authEmailValidator.schema,
-      returnTo: Type.Optional(oauthReturnToValidator.schema)
-    },
-    {
-      additionalProperties: false
-    }
-  ),
-  normalize: normalizeObjectInput,
+const authLoginOtpRequestBodyValidator = deepFreeze({
+  schema: createSchema({
+    email: { ...authEmailFieldDefinition, required: true },
+    returnTo: { ...oauthReturnToFieldDefinition, required: false }
+  }),
+  mode: "create",
   messages: AUTH_LOGIN_OTP_REQUEST_MESSAGES
 });
 
-const authLoginOtpRequestCommand = Object.freeze({
+const authLoginOtpRequestCommand = deepFreeze({
   command: "auth.login.otp.request",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    bodyValidator: authLoginOtpRequestBodyValidator,
-    responseValidator: okMessageResponseValidator,
+    body: authLoginOtpRequestBodyValidator,
+    response: okMessageOutputValidator,
     messages: AUTH_LOGIN_OTP_REQUEST_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze([])
-  })
+    invalidates: []
+  }
 });
 
 export {
   authLoginOtpRequestBodyValidator,
-  okMessageResponseValidator,
+  okMessageOutputValidator,
   AUTH_LOGIN_OTP_REQUEST_MESSAGES,
   authLoginOtpRequestCommand
 };

package/src/shared/commands/authLoginOtpVerifyCommand.js

@@ -1,10 +1,10 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
   authEmailValidator,
   authRecoveryTokenValidator,
   createCommandMessages,
-  otpVerifyResponseValidator
+  otpVerifyOutputValidator
 } from "./authCommandValidators.js";
 
 const AUTH_LOGIN_OTP_VERIFY_MESSAGES = createCommandMessages({
@@ -27,38 +27,45 @@ const AUTH_LOGIN_OTP_VERIFY_MESSAGES = createCommandMessages({
   }
 });
 
-const authLoginOtpVerifyBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      email: Type.Optional(authEmailValidator.schema),
-      token: Type.Optional(authRecoveryTokenValidator.schema),
-      tokenHash: Type.Optional(authRecoveryTokenValidator.schema),
-      type: Type.Optional(Type.Literal("email"))
+const authLoginOtpVerifyBodyValidator = deepFreeze({
+  schema: createSchema({
+    email: {
+      ...authEmailValidator,
+      required: false
+    },
+    token: {
+      ...authRecoveryTokenValidator,
+      required: false
     },
-    {
-      additionalProperties: false,
-      minProperties: 1
+    tokenHash: {
+      ...authRecoveryTokenValidator,
+      required: false
+    },
+    type: {
+      type: "string",
+      required: false,
+      enum: ["email"]
     }
-  ),
-  normalize: normalizeObjectInput,
+  }),
+  mode: "patch",
   messages: AUTH_LOGIN_OTP_VERIFY_MESSAGES
 });
 
-const authLoginOtpVerifyCommand = Object.freeze({
+const authLoginOtpVerifyCommand = deepFreeze({
   command: "auth.login.otp.verify",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    bodyValidator: authLoginOtpVerifyBodyValidator,
-    responseValidator: otpVerifyResponseValidator,
+    body: authLoginOtpVerifyBodyValidator,
+    response: otpVerifyOutputValidator,
     messages: AUTH_LOGIN_OTP_VERIFY_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze(["auth.session.read"])
-  })
+    invalidates: ["auth.session.read"]
+  }
 });
 
 export {
   authLoginOtpVerifyBodyValidator,
-  otpVerifyResponseValidator,
+  otpVerifyOutputValidator,
   AUTH_LOGIN_OTP_VERIFY_MESSAGES,
   authLoginOtpVerifyCommand
 };

package/src/shared/commands/authLoginPasswordCommand.js

@@ -1,10 +1,10 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
-  authEmailValidator,
-  authLoginPasswordValidator,
+  authEmailFieldDefinition,
+  authLoginPasswordFieldDefinition,
   createCommandMessages,
-  loginResponseValidator
+  loginOutputValidator
 } from "./authCommandValidators.js";
 
 const AUTH_LOGIN_PASSWORD_MESSAGES = createCommandMessages({
@@ -23,35 +23,30 @@ const AUTH_LOGIN_PASSWORD_MESSAGES = createCommandMessages({
   }
 });
 
-const authLoginPasswordBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      email: authEmailValidator.schema,
-      password: authLoginPasswordValidator.schema
-    },
-    {
-      additionalProperties: false
-    }
-  ),
-  normalize: normalizeObjectInput,
+const authLoginPasswordBodyValidator = deepFreeze({
+  schema: createSchema({
+    email: { ...authEmailFieldDefinition, required: true },
+    password: { ...authLoginPasswordFieldDefinition, required: true }
+  }),
+  mode: "create",
   messages: AUTH_LOGIN_PASSWORD_MESSAGES
 });
 
-const authLoginPasswordCommand = Object.freeze({
+const authLoginPasswordCommand = deepFreeze({
   command: "auth.login.password",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    bodyValidator: authLoginPasswordBodyValidator,
-    responseValidator: loginResponseValidator,
+    body: authLoginPasswordBodyValidator,
+    response: loginOutputValidator,
     messages: AUTH_LOGIN_PASSWORD_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze(["auth.session.read"])
-  })
+    invalidates: ["auth.session.read"]
+  }
 });
 
 export {
   authLoginPasswordBodyValidator,
-  loginResponseValidator,
+  loginOutputValidator,
   AUTH_LOGIN_PASSWORD_MESSAGES,
   authLoginPasswordCommand
 };

package/src/shared/commands/authLogoutCommand.js

@@ -1,23 +1,24 @@
 import {
   createCommandMessages,
-  logoutResponseValidator
+  logoutOutputValidator
 } from "./authCommandValidators.js";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 
 const AUTH_LOGOUT_MESSAGES = createCommandMessages();
 
-const authLogoutCommand = Object.freeze({
+const authLogoutCommand = deepFreeze({
   command: "auth.logout",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    responseValidator: logoutResponseValidator,
+    response: logoutOutputValidator,
     messages: AUTH_LOGOUT_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze(["auth.session.read"])
-  })
+    invalidates: ["auth.session.read"]
+  }
 });
 
 export {
-  logoutResponseValidator,
+  logoutOutputValidator,
   AUTH_LOGOUT_MESSAGES,
   authLogoutCommand
 };

package/src/shared/commands/authPasswordRecoveryCompleteCommand.js

@@ -1,11 +1,11 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
   authAccessTokenValidator,
   authRecoveryTokenValidator,
   authRefreshTokenValidator,
   createCommandMessages,
-  okResponseValidator
+  okOutputValidator
 } from "./authCommandValidators.js";
 
 const AUTH_PASSWORD_RECOVERY_COMPLETE_MESSAGES = createCommandMessages({
@@ -29,39 +29,49 @@ const AUTH_PASSWORD_RECOVERY_COMPLETE_MESSAGES = createCommandMessages({
   }
 });
 
-const authPasswordRecoveryCompleteBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      code: Type.Optional(authRecoveryTokenValidator.schema),
-      tokenHash: Type.Optional(authRecoveryTokenValidator.schema),
-      accessToken: Type.Optional(authAccessTokenValidator.schema),
-      refreshToken: Type.Optional(authRefreshTokenValidator.schema),
-      type: Type.Optional(Type.Literal("recovery"))
+const authPasswordRecoveryCompleteBodyValidator = deepFreeze({
+  schema: createSchema({
+    code: {
+      ...authRecoveryTokenValidator,
+      required: false
+    },
+    tokenHash: {
+      ...authRecoveryTokenValidator,
+      required: false
+    },
+    accessToken: {
+      ...authAccessTokenValidator,
+      required: false
     },
-    {
-      additionalProperties: false,
-      minProperties: 1
+    refreshToken: {
+      ...authRefreshTokenValidator,
+      required: false
+    },
+    type: {
+      type: "string",
+      required: false,
+      enum: ["recovery"]
     }
-  ),
-  normalize: normalizeObjectInput,
+  }),
+  mode: "patch",
   messages: AUTH_PASSWORD_RECOVERY_COMPLETE_MESSAGES
 });
 
-const authPasswordRecoveryCompleteCommand = Object.freeze({
+const authPasswordRecoveryCompleteCommand = deepFreeze({
   command: "auth.password.recovery.complete",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    bodyValidator: authPasswordRecoveryCompleteBodyValidator,
-    responseValidator: okResponseValidator,
+    body: authPasswordRecoveryCompleteBodyValidator,
+    response: okOutputValidator,
     messages: AUTH_PASSWORD_RECOVERY_COMPLETE_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze(["auth.session.read"])
-  })
+    invalidates: ["auth.session.read"]
+  }
 });
 
 export {
   authPasswordRecoveryCompleteBodyValidator,
-  okResponseValidator,
+  okOutputValidator,
   AUTH_PASSWORD_RECOVERY_COMPLETE_MESSAGES,
   authPasswordRecoveryCompleteCommand
 };

package/src/shared/commands/authPasswordResetCommand.js

@@ -1,9 +1,9 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
-  authPasswordValidator,
+  authPasswordFieldDefinition,
   createCommandMessages,
-  okMessageResponseValidator
+  okMessageOutputValidator
 } from "./authCommandValidators.js";
 
 const AUTH_PASSWORD_RESET_MESSAGES = createCommandMessages({
@@ -16,34 +16,29 @@ const AUTH_PASSWORD_RESET_MESSAGES = createCommandMessages({
   }
 });
 
-const authPasswordResetBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      password: authPasswordValidator.schema
-    },
-    {
-      additionalProperties: false
-    }
-  ),
-  normalize: normalizeObjectInput,
+const authPasswordResetBodyValidator = deepFreeze({
+  schema: createSchema({
+    password: { ...authPasswordFieldDefinition, required: true }
+  }),
+  mode: "create",
   messages: AUTH_PASSWORD_RESET_MESSAGES
 });
 
-const authPasswordResetCommand = Object.freeze({
+const authPasswordResetCommand = deepFreeze({
   command: "auth.password.reset",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    bodyValidator: authPasswordResetBodyValidator,
-    responseValidator: okMessageResponseValidator,
+    body: authPasswordResetBodyValidator,
+    response: okMessageOutputValidator,
     messages: AUTH_PASSWORD_RESET_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze(["auth.session.read"])
-  })
+    invalidates: ["auth.session.read"]
+  }
 });
 
 export {
   authPasswordResetBodyValidator,
-  okMessageResponseValidator,
+  okMessageOutputValidator,
   AUTH_PASSWORD_RESET_MESSAGES,
   authPasswordResetCommand
 };

package/src/shared/commands/authPasswordResetRequestCommand.js

@@ -1,9 +1,9 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "../inputNormalization.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
 import {
-  authEmailValidator,
+  authEmailFieldDefinition,
   createCommandMessages,
-  okMessageResponseValidator
+  okMessageOutputValidator
 } from "./authCommandValidators.js";
 
 const AUTH_PASSWORD_RESET_REQUEST_MESSAGES = createCommandMessages({
@@ -17,34 +17,29 @@ const AUTH_PASSWORD_RESET_REQUEST_MESSAGES = createCommandMessages({
   }
 });
 
-const authPasswordResetRequestBodyValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      email: authEmailValidator.schema
-    },
-    {
-      additionalProperties: false
-    }
-  ),
-  normalize: normalizeObjectInput,
+const authPasswordResetRequestBodyValidator = deepFreeze({
+  schema: createSchema({
+    email: { ...authEmailFieldDefinition, required: true }
+  }),
+  mode: "create",
   messages: AUTH_PASSWORD_RESET_REQUEST_MESSAGES
 });
 
-const authPasswordResetRequestCommand = Object.freeze({
+const authPasswordResetRequestCommand = deepFreeze({
   command: "auth.password.reset.request",
-  operation: Object.freeze({
+  operation: {
     method: "POST",
-    bodyValidator: authPasswordResetRequestBodyValidator,
-    responseValidator: okMessageResponseValidator,
+    body: authPasswordResetRequestBodyValidator,
+    response: okMessageOutputValidator,
     messages: AUTH_PASSWORD_RESET_REQUEST_MESSAGES,
     idempotent: false,
-    invalidates: Object.freeze([])
-  })
+    invalidates: []
+  }
 });
 
 export {
   authPasswordResetRequestBodyValidator,
-  okMessageResponseValidator,
+  okMessageOutputValidator,
   AUTH_PASSWORD_RESET_REQUEST_MESSAGES,
   authPasswordResetRequestCommand
 };