@elench/testkit 0.1.81 → 0.1.83

package/lib/config-api/index.d.ts

@@ -192,22 +192,22 @@ export interface TestkitFileMetadata {
   skip?: string | { reason: string };
 }
 
-export interface ProfileRequestContext {
+export interface AuthRequestContext {
   actor: string;
   actorIndex: number;
   env: RuntimeEnv;
   phase: string;
 }
 
-export type ProfileValueFactory<TValue> =
+export type AuthValueFactory<TValue> =
   | TValue
-  | ((context: ProfileRequestContext) => TValue);
+  | ((context: AuthRequestContext) => TValue);
 
-export interface ProfileRequestConfig {
-  body?: ProfileValueFactory<unknown>;
+export interface AuthRequestConfig {
+  body?: AuthValueFactory<unknown>;
   contentTypeJson?: boolean;
   expect?: number | number[];
-  headers?: ProfileValueFactory<Record<string, string>>;
+  headers?: AuthValueFactory<Record<string, string>>;
   method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
   path: string;
 }
@@ -222,25 +222,13 @@ export interface SessionAuthHeaderConfig {
   source: SessionAuthSourceConfig;
 }
 
-export interface SessionCaptureConfig {
-  auth?: SessionAuthHeaderConfig;
-  cookies?: Record<string, string>;
-  fields?: Record<string, string>;
-}
-
-export interface SessionActorConfig {
-  bootstrap?: ProfileRequestConfig | ProfileRequestConfig[];
-  login: ProfileRequestConfig;
-  session: SessionCaptureConfig;
-}
-
-export interface ProfileHeaderContext<TSession = unknown> {
+export interface AuthProfileHeaderContext<TSession = unknown> {
   actor: string | null;
   env: RuntimeEnv;
   session: TSession | null;
 }
 
-export interface ProfileSessionHeaderConfig {
+export interface AuthProfileSessionHeaderConfig {
   actor?: string;
   field: string;
   header: string;
@@ -252,125 +240,113 @@ export interface DeterministicForwardedForConfig {
   seed?: string;
 }
 
-export interface ProfileHeaderConfig<TSession = unknown> {
+export interface AuthProfileHeaderOptions<TSession = unknown> {
   contentTypeJson?: boolean;
   forwardedFor?: "deterministic" | DeterministicForwardedForConfig;
-  fromSession?: ProfileSessionHeaderConfig[];
-  values?: Record<string, string> | ((context: ProfileHeaderContext<TSession>) => Record<string, string>);
-}
-
-export interface RawHttpProfileOptions {
-  env?: RuntimeEnv;
-  headers?: ProfileHeaderConfig;
-  options?: RuntimeOptions;
-}
-
-export interface SessionHttpProfileOptions {
-  actor: SessionActorConfig;
-  env?: RuntimeEnv;
-  headers?: ProfileHeaderConfig<Record<string, unknown>>;
-  options?: RuntimeOptions;
+  fromSession?: AuthProfileSessionHeaderConfig[];
+  values?: Record<string, string> | ((context: AuthProfileHeaderContext<TSession>) => Record<string, string>);
 }
 
-export interface MultiActorHttpProfileOptions {
-  actors: Record<string, SessionActorConfig>;
-  env?: RuntimeEnv;
-  headers?: ProfileHeaderConfig<Record<string, Record<string, unknown>>>;
-  options?: RuntimeOptions;
-  primaryActor?: string;
-}
-
-export interface LocalJsonIdentityContext {
-  actor: string;
-}
-
-export type LocalJsonIdentityValue = string | ((context: LocalJsonIdentityContext) => string);
-
-export interface LocalJsonActorIdentityConfig {
-  email?: LocalJsonIdentityValue;
+export interface AuthTopologyActorConfig {
+  email?: string;
   loginBody?: Record<string, unknown>;
-  name?: LocalJsonIdentityValue;
-  organizationName?: LocalJsonIdentityValue;
-  password?: LocalJsonIdentityValue;
+  name?: string;
+  org?: string;
+  organizationName?: string;
+  password?: string;
   signupBody?: Record<string, unknown>;
 }
 
-export interface LocalJsonSessionAuthOptions {
-  header?: string;
-  prefix?: string;
-  sourceKey?: string;
+export interface AuthTopologyOrgConfig {
+  name?: string;
 }
 
-export interface LocalJsonSessionOptions {
-  auth?: LocalJsonSessionAuthOptions;
+export interface JsonSessionContractOptions {
   authCookie?: string;
-  cookies?: Record<string, string>;
-  fields?: Record<string, string>;
+  authHeader?: string;
+  authPrefix?: string;
+  authSourceKey?: string;
+  contentTypeJson?: boolean;
+  forwardedFor?: "deterministic" | DeterministicForwardedForConfig;
+  loginExpect?: number | number[];
+  loginPath?: string;
+  organizationHeader?: false | string;
   organizationIdPath?: string;
   refreshCookie?: string;
+  sessionCookies?: Record<string, string>;
+  sessionFields?: Record<string, string>;
+  signup?: false;
+  signupExpect?: number | number[];
+  signupPath?: string;
 }
 
-export interface LocalJsonOrganizationHeaderConfig {
-  actor?: string;
-  field?: string;
-  header?: string;
+export interface JsonSessionContract {
+  kind: "json-session";
 }
 
-export interface LocalJsonHeaderOptions {
-  contentTypeJson?: boolean;
-  forwardedFor?: "deterministic" | DeterministicForwardedForConfig;
-  organization?: false | string | LocalJsonOrganizationHeaderConfig;
-  values?: Record<string, string> | ((context: ProfileHeaderContext<unknown>) => Record<string, string>);
+export interface SingleOrgTopologyOptions {
+  actors?: string[] | Record<string, string | AuthTopologyActorConfig>;
+  namespace: string;
+  org?: string;
+  orgs?: Record<string, AuthTopologyOrgConfig>;
+  password?: string;
 }
 
-export interface LocalJsonSignupOptions {
-  enabled?: boolean;
-  expect?: number | number[];
-  path?: string;
+export interface CrossOrgTopologyOptions {
+  actors: string[] | Record<string, string | AuthTopologyActorConfig>;
+  namespace: string;
+  orgs?: Record<string, AuthTopologyOrgConfig>;
+  password?: string;
 }
 
-export interface LocalJsonLoginOptions {
-  expect?: number | number[];
-  path?: string;
+export interface AuthTopology {
+  kind: "auth-topology";
 }
 
-export interface LocalJsonProfileOptions {
+export interface AuthActorProfileOptions {
   env?: RuntimeEnv;
-  headers?: LocalJsonHeaderOptions;
-  identities?: Record<string, LocalJsonActorIdentityConfig>;
-  login?: LocalJsonLoginOptions;
+  headers?: AuthProfileHeaderOptions<Record<string, unknown>>;
   options?: RuntimeOptions;
-  password?: LocalJsonIdentityValue;
-  session?: LocalJsonSessionOptions;
-  signup?: false | LocalJsonSignupOptions;
 }
 
-export interface LocalJsonSessionProfileOptions {
-  actor?: string;
+export interface AuthActorsProfileOptions {
+  actors: string[];
   env?: RuntimeEnv;
-  headers?: LocalJsonHeaderOptions;
-  identity?: LocalJsonActorIdentityConfig;
+  headers?: AuthProfileHeaderOptions<Record<string, unknown>>;
   options?: RuntimeOptions;
+  primaryActor?: string;
 }
 
-export interface LocalJsonMultiActorProfileOptions {
-  actors?: string[] | Record<string, LocalJsonActorIdentityConfig>;
+export interface AuthRawProfileOptions {
   env?: RuntimeEnv;
-  headers?: LocalJsonHeaderOptions;
+  headers?: AuthProfileHeaderOptions;
   options?: RuntimeOptions;
-  primaryActor?: string;
 }
 
-export interface LocalJsonRawProfileOptions {
-  env?: RuntimeEnv;
-  headers?: LocalJsonHeaderOptions;
-  options?: RuntimeOptions;
+export interface AuthActorProfileDescriptor {
+  kind: "actor";
+  actor: string;
+}
+
+export interface AuthActorsProfileDescriptor {
+  kind: "actors";
+  actors: string[];
+  primaryActor: string;
 }
 
-export interface LocalJsonProfileBuilder {
-  multiActor(options?: LocalJsonMultiActorProfileOptions): HttpSuiteConfig<Record<string, Record<string, unknown>>>;
-  raw(options?: LocalJsonRawProfileOptions): HttpSuiteConfig<any>;
-  session(options?: LocalJsonSessionProfileOptions): HttpSuiteConfig<Record<string, unknown>>;
+export interface AuthRawProfileDescriptor {
+  kind: "raw";
+}
+
+export type AuthProfileDescriptor =
+  | AuthActorProfileDescriptor
+  | AuthActorsProfileDescriptor
+  | AuthRawProfileDescriptor;
+
+export interface AuthFixture {
+  contract: JsonSessionContract;
+  topology: AuthTopology;
+  profiles(definitions: Record<string, AuthProfileDescriptor>): Record<string, HttpSuiteConfig<any>>;
 }
 
 export interface NodeAppOptions extends Omit<ServiceConfig, "local" | "runtime" | "env"> {
@@ -449,12 +425,20 @@ export declare const database: {
 export declare const toolchain: {
   node(options?: NodeToolchainConfig): NodeToolchainConfig;
 };
-export declare const profiles: {
-  custom<T extends HttpSuiteConfig>(profile: T): T;
-  localJson(options?: LocalJsonProfileOptions): LocalJsonProfileBuilder;
-  multiActor(options: MultiActorHttpProfileOptions): HttpSuiteConfig<Record<string, Record<string, unknown>>>;
-  raw(options?: RawHttpProfileOptions): HttpSuiteConfig<any>;
-  session(options: SessionHttpProfileOptions): HttpSuiteConfig<Record<string, unknown>>;
+export declare const auth: {
+  fixture(options: { contract: JsonSessionContract; topology: AuthTopology }): AuthFixture;
+  contracts: {
+    jsonSession(options?: JsonSessionContractOptions): JsonSessionContract;
+  };
+  topologies: {
+    crossOrg(options: CrossOrgTopologyOptions): AuthTopology;
+    singleOrg(options: SingleOrgTopologyOptions): AuthTopology;
+  };
+  profile: {
+    actor(actorName: string, options?: AuthActorProfileOptions): AuthActorProfileDescriptor;
+    actors(options: AuthActorsProfileOptions): AuthActorsProfileDescriptor;
+    raw(options?: AuthRawProfileOptions): AuthRawProfileDescriptor;
+  };
 };
 
 export declare function registerRepoConfig(config: unknown): void;

package/lib/config-api/index.mjs

@@ -9,12 +9,14 @@ import {
   runtimeJson,
 } from "./runtime.mjs";
 import {
-  customProfile,
-  localJsonProfile,
-  multiActorProfile,
-  rawProfile,
-  sessionProfile,
-} from "./profiles.mjs";
+  actorProfile as createActorProfile,
+  actorsProfile as createActorsProfile,
+  authFixture as createAuthFixture,
+  crossOrgTopology as createCrossOrgTopology,
+  jsonSessionContract as createJsonSessionContract,
+  rawAuthProfile as createRawAuthProfile,
+  singleOrgTopology as createSingleOrgTopology,
+} from "./auth-fixtures.mjs";
 
 export function defineConfig(config) {
   return config || {};
@@ -264,12 +266,20 @@ export const toolchain = {
   node: nodeToolchain,
 };
 
-export const profiles = {
-  custom: customProfile,
-  localJson: localJsonProfile,
-  multiActor: multiActorProfile,
-  raw: rawProfile,
-  session: sessionProfile,
+export const auth = {
+  fixture: createAuthFixture,
+  contracts: {
+    jsonSession: createJsonSessionContract,
+  },
+  topologies: {
+    crossOrg: createCrossOrgTopology,
+    singleOrg: createSingleOrgTopology,
+  },
+  profile: {
+    actor: createActorProfile,
+    actors: createActorsProfile,
+    raw: createRawAuthProfile,
+  },
 };
 
 export {