@reactionary/core 0.12.4 → 0.12.6

package/capabilities/identity.capability.js

@@ -1,4 +1,5 @@
 import { BaseCapability } from "./base.capability.js";
+const PENDING_EXTERNAL_LOGIN_TTL_MS = 10 * 60 * 1e3;
 class IdentityCapability extends BaseCapability {
   getResourceName() {
     return "identity";
@@ -7,6 +8,34 @@ class IdentityCapability extends BaseCapability {
     this.context.session.identityContext.lastUpdated = /* @__PURE__ */ new Date();
     this.context.session.identityContext.identity = identity;
   }
+  setPendingExternalLogin(provider, state, data) {
+    this.context.session.identityContext.pendingExternalLogin = {
+      provider,
+      state,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...data ? { data } : {}
+    };
+  }
+  /**
+   * Returns the pending login, and clears it, when provider and state match a login started in this session within
+   * the last 10 minutes. Returns undefined otherwise. A pending login can only be taken once.
+   */
+  takePendingExternalLogin(provider, state) {
+    const pending = this.context.session.identityContext.pendingExternalLogin;
+    delete this.context.session.identityContext.pendingExternalLogin;
+    if (!pending || !state) {
+      return void 0;
+    }
+    const fresh = Date.now() - new Date(pending.createdAt).getTime() <= PENDING_EXTERNAL_LOGIN_TTL_MS;
+    if (!fresh || pending.provider !== provider || pending.state !== state) {
+      return void 0;
+    }
+    return { data: pending.data ?? {} };
+  }
+  /** Returns true, and clears the pending login, when provider and state match a login started in this session within the last 10 minutes. */
+  consumePendingExternalLogin(provider, state) {
+    return this.takePendingExternalLogin(provider, state) !== void 0;
+  }
 }
 export {
   IdentityCapability

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.12.4",
+  "version": "0.12.6",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",

package/schemas/errors/identity-conflict.error.js

@@ -0,0 +1,8 @@
+import * as z from "zod";
+const IdentityConflictErrorSchema = z.looseObject({
+  type: z.literal("IdentityConflict"),
+  message: z.string().nonempty()
+});
+export {
+  IdentityConflictErrorSchema
+};

package/schemas/errors/index.js

@@ -1,4 +1,5 @@
 export * from "./generic.error.js";
+export * from "./identity-conflict.error.js";
 export * from "./invalid-input.error.js";
 export * from "./invalid-output.error.js";
 export * from "./not-found.error.js";

package/schemas/models/identity-provider.model.js

@@ -0,0 +1,26 @@
+import * as z from "zod";
+import { BaseModelSchema } from "./base.model.js";
+const IdentityProviderIdentifierSchema = z.looseObject({
+  key: z.string()
+});
+const IdentityProviderSchema = BaseModelSchema.extend({
+  identifier: IdentityProviderIdentifierSchema,
+  displayName: z.string(),
+  brand: z.string().optional().meta({ description: "A neutral slug for the identity provider's brand, such as google, apple, amazon, facebook, microsoft or email, so a storefront can choose its own icon. Absent when the brand is not known." }),
+  flow: z.enum(["credentials", "redirect"]).meta({ description: "credentials: the shopper types a username and password into the storefront. redirect: the shopper is sent to an external identity provider and returns with a code." })
+});
+const ExternalLoginRedirectSchema = z.looseObject({
+  location: z.url().meta({ description: "Where to send the shopper to authenticate with the external identity provider." })
+});
+const PASSWORD_IDENTITY_PROVIDER = IdentityProviderSchema.parse({
+  identifier: { key: "password" },
+  displayName: "Email and password",
+  brand: "email",
+  flow: "credentials"
+});
+export {
+  ExternalLoginRedirectSchema,
+  IdentityProviderIdentifierSchema,
+  IdentityProviderSchema,
+  PASSWORD_IDENTITY_PROVIDER
+};

package/schemas/models/index.js

@@ -6,6 +6,7 @@ export * from "./category.model.js";
 export * from "./currency.model.js";
 export * from "./identifiers.model.js";
 export * from "./identity.model.js";
+export * from "./identity-provider.model.js";
 export * from "./inventory.model.js";
 export * from "./payment.model.js";
 export * from "./price.model.js";

package/schemas/mutations/identity.mutation.js

@@ -1,5 +1,6 @@
 import * as z from "zod";
 import { BaseMutationSchema } from "./base.mutation.js";
+import { IdentityProviderIdentifierSchema } from "../models/identity-provider.model.js";
 const IdentityMutationLoginSchema = BaseMutationSchema.extend({
   username: z.string(),
   password: z.string()
@@ -9,8 +10,19 @@ const IdentityMutationRegisterSchema = BaseMutationSchema.extend({
   username: z.string(),
   password: z.string()
 });
+const IdentityMutationStartExternalLoginSchema = BaseMutationSchema.extend({
+  provider: IdentityProviderIdentifierSchema,
+  callbackUrl: z.url().meta({ description: "The storefront URL the identity provider returns the shopper to. Must be registered with the identity provider." })
+});
+const IdentityMutationCompleteExternalLoginSchema = BaseMutationSchema.extend({
+  provider: IdentityProviderIdentifierSchema,
+  callbackUrl: z.url().meta({ description: "The same callbackUrl that was passed to startExternalLogin." }),
+  callbackParameters: z.record(z.string(), z.string()).meta({ description: "The query parameters the identity provider appended to the callback URL, passed through unchanged." })
+});
 export {
+  IdentityMutationCompleteExternalLoginSchema,
   IdentityMutationLoginSchema,
   IdentityMutationLogoutSchema,
-  IdentityMutationRegisterSchema
+  IdentityMutationRegisterSchema,
+  IdentityMutationStartExternalLoginSchema
 };

package/schemas/queries/identity.query.js

@@ -1,5 +1,7 @@
 import { BaseQuerySchema } from "./base.query.js";
 const IdentityQuerySelfSchema = BaseQuerySchema.extend({});
+const IdentityQueryProvidersSchema = BaseQuerySchema.extend({});
 export {
+  IdentityQueryProvidersSchema,
   IdentityQuerySelfSchema
 };

package/schemas/session.schema.js

@@ -11,7 +11,13 @@ const LanguageContextSchema = z.looseObject({
 });
 const IdentityContextSchema = z.looseObject({
   identity: IdentitySchema,
-  lastUpdated: z.coerce.date()
+  lastUpdated: z.coerce.date(),
+  pendingExternalLogin: z.looseObject({
+    provider: z.string(),
+    state: z.string(),
+    createdAt: z.coerce.date(),
+    data: z.record(z.string(), z.string()).optional().meta({ description: "Provider specific values that must survive the redirect, such as a PKCE code verifier and nonce." })
+  }).optional().meta({ description: "An external login that has been started but not completed. Binds the callback to the browser that started it." })
 });
 const SessionSchema = z.looseObject({
   id: z.string().optional().meta({ description: "The id of the visitor's current session, set by the storefront. A long-lived visitor id belongs in marketingContext.identifier, not here." }),

package/src/capabilities/identity.capability.d.ts

@@ -1,6 +1,8 @@
+import type { ExternalLoginRedirect, IdentityProvider } from "../schemas/models/identity-provider.model.js";
 import type { Identity } from "../schemas/models/identity.model.js";
-import type { IdentityMutationLogin, IdentityMutationLogout, IdentityMutationRegister } from "../schemas/mutations/identity.mutation.js";
-import type { IdentityQuerySelf } from "../schemas/queries/identity.query.js";
+import type { IdentityConflictError } from "../schemas/errors/identity-conflict.error.js";
+import type { IdentityMutationCompleteExternalLogin, IdentityMutationLogin, IdentityMutationLogout, IdentityMutationRegister, IdentityMutationStartExternalLogin } from "../schemas/mutations/identity.mutation.js";
+import type { IdentityQueryProviders, IdentityQuerySelf } from "../schemas/queries/identity.query.js";
 import type { Result } from "../schemas/result.js";
 import { BaseCapability } from "./base.capability.js";
 export declare abstract class IdentityCapability<TIdentity extends Identity = Identity> extends BaseCapability {
@@ -8,6 +10,22 @@ export declare abstract class IdentityCapability<TIdentity extends Identity = Id
     abstract login(payload: IdentityMutationLogin): Promise<Result<TIdentity>>;
     abstract logout(payload: IdentityMutationLogout): Promise<Result<TIdentity>>;
     abstract register(payload: IdentityMutationRegister): Promise<Result<TIdentity>>;
+    /** The ways a shopper can sign in with this backend. */
+    abstract listProviders(payload: IdentityQueryProviders): Promise<Result<IdentityProvider[]>>;
+    /** Begins a redirect flow. The caller sends the shopper to the returned location. */
+    abstract startExternalLogin(payload: IdentityMutationStartExternalLogin): Promise<Result<ExternalLoginRedirect>>;
+    /** Completes a redirect flow from the parameters the identity provider appended to the callback URL. */
+    abstract completeExternalLogin(payload: IdentityMutationCompleteExternalLogin): Promise<Result<TIdentity, IdentityConflictError>>;
     protected getResourceName(): string;
     protected updateIdentityContext(identity: TIdentity): void;
+    protected setPendingExternalLogin(provider: string, state: string, data?: Record<string, string>): void;
+    /**
+     * Returns the pending login, and clears it, when provider and state match a login started in this session within
+     * the last 10 minutes. Returns undefined otherwise. A pending login can only be taken once.
+     */
+    protected takePendingExternalLogin(provider: string, state: string | undefined): {
+        data: Record<string, string>;
+    } | undefined;
+    /** Returns true, and clears the pending login, when provider and state match a login started in this session within the last 10 minutes. */
+    protected consumePendingExternalLogin(provider: string, state: string | undefined): boolean;
 }

package/src/schemas/errors/identity-conflict.error.d.ts

@@ -0,0 +1,7 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+export declare const IdentityConflictErrorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"IdentityConflict">;
+    message: z.ZodString;
+}, z.core.$loose>;
+export type IdentityConflictError = InferType<typeof IdentityConflictErrorSchema>;

package/src/schemas/errors/index.d.ts

@@ -1,4 +1,5 @@
 export * from './generic.error.js';
+export * from './identity-conflict.error.js';
 export * from './invalid-input.error.js';
 export * from './invalid-output.error.js';
 export * from './not-found.error.js';

package/src/schemas/models/identity-provider.model.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+export declare const IdentityProviderIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$loose>;
+export declare const IdentityProviderSchema: z.ZodObject<{
+    identifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    displayName: z.ZodString;
+    brand: z.ZodOptional<z.ZodString>;
+    flow: z.ZodEnum<{
+        credentials: "credentials";
+        redirect: "redirect";
+    }>;
+}, z.core.$loose>;
+export declare const ExternalLoginRedirectSchema: z.ZodObject<{
+    location: z.ZodURL;
+}, z.core.$loose>;
+export declare const PASSWORD_IDENTITY_PROVIDER: InferType<typeof IdentityProviderSchema>;
+export type IdentityProviderIdentifier = InferType<typeof IdentityProviderIdentifierSchema>;
+export type IdentityProvider = InferType<typeof IdentityProviderSchema>;
+export type ExternalLoginRedirect = InferType<typeof ExternalLoginRedirectSchema>;

package/src/schemas/models/index.d.ts

@@ -6,6 +6,7 @@ export * from './category.model.js';
 export * from './currency.model.js';
 export * from './identifiers.model.js';
 export * from './identity.model.js';
+export * from './identity-provider.model.js';
 export * from './inventory.model.js';
 export * from './payment.model.js';
 export * from './price.model.js';

package/src/schemas/mutations/identity.mutation.d.ts

@@ -9,6 +9,23 @@ export declare const IdentityMutationRegisterSchema: z.ZodObject<{
     username: z.ZodString;
     password: z.ZodString;
 }, z.core.$loose>;
+export declare const IdentityMutationStartExternalLoginSchema: z.ZodObject<{
+    provider: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    callbackUrl: z.ZodURL;
+}, z.core.$loose>;
+export declare const IdentityMutationCompleteExternalLoginSchema: z.ZodObject<{
+    provider: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    callbackUrl: z.ZodURL;
+    callbackParameters: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$loose>;
 export type IdentityMutationLogin = InferType<typeof IdentityMutationLoginSchema>;
 export type IdentityMutationLogout = InferType<typeof IdentityMutationLogoutSchema>;
 export type IdentityMutationRegister = InferType<typeof IdentityMutationRegisterSchema>;
+export type IdentityMutationStartExternalLogin = InferType<typeof IdentityMutationStartExternalLoginSchema>;
+export type IdentityMutationCompleteExternalLogin = Omit<InferType<typeof IdentityMutationCompleteExternalLoginSchema>, 'callbackParameters'> & {
+    callbackParameters: Record<string, string>;
+};

package/src/schemas/queries/identity.query.d.ts

@@ -1,4 +1,6 @@
 import type * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const IdentityQuerySelfSchema: z.ZodObject<{}, z.core.$loose>;
+export declare const IdentityQueryProvidersSchema: z.ZodObject<{}, z.core.$loose>;
+export type IdentityQueryProviders = InferType<typeof IdentityQueryProvidersSchema>;
 export type IdentityQuerySelf = InferType<typeof IdentityQuerySelfSchema>;

package/src/schemas/session.schema.d.ts

@@ -203,6 +203,12 @@ export declare const IdentityContextSchema: z.ZodObject<{
         type: z.ZodLiteral<"Registered">;
     }, z.core.$loose>], "type">;
     lastUpdated: z.ZodCoercedDate<unknown>;
+    pendingExternalLogin: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        state: z.ZodString;
+        createdAt: z.ZodCoercedDate<unknown>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export declare const SessionSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -221,6 +227,12 @@ export declare const SessionSchema: z.ZodObject<{
             type: z.ZodLiteral<"Registered">;
         }, z.core.$loose>], "type">;
         lastUpdated: z.ZodCoercedDate<unknown>;
+        pendingExternalLogin: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            state: z.ZodString;
+            createdAt: z.ZodCoercedDate<unknown>;
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$loose>>;
     }, z.core.$loose>;
     marketingContext: z.ZodDefault<z.ZodObject<{
         identifier: z.ZodObject<{
@@ -258,6 +270,12 @@ export declare const RequestContextSchema: z.ZodObject<{
                 type: z.ZodLiteral<"Registered">;
             }, z.core.$loose>], "type">;
             lastUpdated: z.ZodCoercedDate<unknown>;
+            pendingExternalLogin: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                state: z.ZodString;
+                createdAt: z.ZodCoercedDate<unknown>;
+                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$loose>>;
         }, z.core.$loose>;
         marketingContext: z.ZodDefault<z.ZodObject<{
             identifier: z.ZodObject<{