@slates/provider 1.0.0-rc.17 → 1.0.0-rc.18

package/src/adapter/spec.ts

@@ -0,0 +1,154 @@
+import {
+  type SlateActionParameters,
+  SlatePublicTool,
+  SlateTool,
+  SlateTrigger
+} from '../action';
+import { SlateDeclarationError } from '../error';
+import type { SlateSpecification } from '../specification/specification';
+import { SlateAdapter } from './adapter';
+
+export interface SlateAdapterCapability {
+  id: string;
+  value: any;
+}
+
+export interface SlateAdapterSpecParameters {
+  id: string;
+  name: string;
+  capabilities?: SlateAdapterCapability[];
+}
+
+export class SlateAdapterSpec {
+  private constructor(
+    private readonly _params: {
+      id: string;
+      name: string;
+      capabilities: SlateAdapterCapability[];
+    }
+  ) {}
+
+  static create(params: SlateAdapterSpecParameters): SlateAdapterSpec {
+    let id = params.id?.trim();
+    let name = params.name?.trim();
+
+    if (!id) {
+      throw new SlateDeclarationError('Adapter id must be a non-empty string');
+    }
+    if (!name) {
+      throw new SlateDeclarationError('Adapter name must be a non-empty string');
+    }
+
+    return new SlateAdapterSpec({
+      id,
+      name,
+      capabilities: validateCapabilities(params.capabilities ?? [])
+    });
+  }
+
+  get id() {
+    return this._params.id;
+  }
+
+  get name() {
+    return this._params.name;
+  }
+
+  get capabilities() {
+    return this._params.capabilities;
+  }
+
+  get parameters() {
+    return this._params;
+  }
+
+  tool<ConfigType extends {}, AuthType extends {}>(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateActionParameters
+  ) {
+    return SlateTool.create(spec, this.linkAction(params));
+  }
+
+  publicTool<ConfigType extends {}, AuthType extends {}>(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateActionParameters
+  ) {
+    return SlatePublicTool.create(spec, this.linkAction(params));
+  }
+
+  trigger<ConfigType extends {}, AuthType extends {}>(
+    spec: SlateSpecification<ConfigType, AuthType>,
+    params: SlateActionParameters
+  ) {
+    return SlateTrigger.create(spec, this.linkAction(params));
+  }
+
+  register<ConfigType extends {}, AuthType extends {}>(params: {
+    tools: SlateTool<ConfigType, AuthType, any, any>[];
+    triggers: SlateTrigger<ConfigType, AuthType, any, any>[];
+  }): SlateAdapter<ConfigType, AuthType> {
+    let actions = [...params.tools, ...params.triggers];
+    let seenKeys = new Set<string>();
+
+    for (let action of actions) {
+      if (action.adapter && action.adapter !== this.id) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" is linked to adapter "${action.adapter}", not "${this.id}"`
+        );
+      }
+
+      if (!action.adapter) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" must be created with this adapter's tool(), publicTool(), or trigger() helpers`
+        );
+      }
+
+      if (seenKeys.has(action.key)) {
+        throw new SlateDeclarationError(
+          `Adapter "${this.id}" already has an action with key "${action.key}"`
+        );
+      }
+
+      seenKeys.add(action.key);
+    }
+
+    return new SlateAdapter(this, params.tools, params.triggers);
+  }
+
+  private linkAction(params: SlateActionParameters): SlateActionParameters {
+    if (params.adapter != null && params.adapter !== this.id) {
+      throw new SlateDeclarationError(
+        `Action "${params.key}" cannot be linked to adapter "${this.id}" because it is already linked to "${params.adapter}"`
+      );
+    }
+
+    return {
+      ...params,
+      adapter: this.id
+    };
+  }
+}
+
+export let adapterSpec = (params: SlateAdapterSpecParameters) =>
+  SlateAdapterSpec.create(params);
+
+let validateCapabilities = (capabilities: SlateAdapterCapability[]) => {
+  let seenIds = new Set<string>();
+
+  return capabilities.map(capability => {
+    let id = capability.id?.trim();
+    if (!id) {
+      throw new SlateDeclarationError('Adapter capability ids must be non-empty strings');
+    }
+    if (seenIds.has(id)) {
+      throw new SlateDeclarationError(`Adapter capability "${id}" is defined more than once`);
+    }
+
+    seenIds.add(id);
+
+    return {
+      id,
+      value: capability.value
+    };
+  });
+};

package/src/axios/trace.ts

@@ -1,5 +1,5 @@
 import type { AxiosError, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
-import type { SlateContext } from '../context';
+import type { SlatePublicContext } from '../context';
 
 export interface SlateHttpTraceTextBody {
   contentType?: string;
@@ -29,7 +29,7 @@ export interface SlateHttpTrace {
 }
 
 interface SlateHttpTraceDraft {
-  context: SlateContext<any, any, any>;
+  context: SlatePublicContext<any>;
   startedAt: string;
   startedAtMs: number;
   request: SlateHttpTrace['request'];
@@ -664,7 +664,7 @@ let clearTraceDraft = (
 
 export let attachHttpTraceDraft = (
   config: InternalAxiosRequestConfig,
-  context: SlateContext<any, any, any>
+  context: SlatePublicContext<any>
 ) => {
   let traceAwareConfig = config as TraceAwareAxiosRequestConfig;
   let contentType = getContentType(config.headers);

package/src/context/context.ts

@@ -2,32 +2,22 @@ import type { SlateHttpTrace } from '../axios/trace';
 import type { SlateLogger, SlateLogMessageInput } from '../logger';
 import type { SlateSpecification } from '../specification/specification';
 
-export class SlateContext<ConfigType extends {}, AuthType extends {}, InputType extends {}> {
-  #config: ConfigType;
+export class SlatePublicContext<InputType extends {}> {
   #input: InputType;
-  #auth: AuthType;
   #httpTraces: SlateHttpTrace[] = [];
 
   constructor(
-    config: ConfigType,
     input: InputType,
-    auth: AuthType,
-    private readonly spec: SlateSpecification<ConfigType, AuthType>,
+    private readonly spec: SlateSpecification<any, any>,
     private readonly logger: SlateLogger
   ) {
-    this.#config = config;
     this.#input = input;
-    this.#auth = auth;
   }
 
   get specification() {
     return this.spec;
   }
 
-  get config() {
-    return Object.freeze(this.#config);
-  }
-
   get input() {
     return Object.freeze(this.#input);
   }
@@ -56,10 +46,6 @@ export class SlateContext<ConfigType extends {}, AuthType extends {}, InputType
       : never;
   }
 
-  get auth() {
-    return Object.freeze(this.#auth);
-  }
-
   recordHttpTrace(trace: SlateHttpTrace) {
     this.#httpTraces.push(trace);
   }
@@ -101,3 +87,32 @@ export class SlateContext<ConfigType extends {}, AuthType extends {}, InputType
     this.logger.progress(message);
   }
 }
+
+export class SlateContext<
+  ConfigType extends {},
+  AuthType extends {},
+  InputType extends {}
+> extends SlatePublicContext<InputType> {
+  #config: ConfigType;
+  #auth: AuthType;
+
+  constructor(
+    config: ConfigType,
+    input: InputType,
+    auth: AuthType,
+    spec: SlateSpecification<ConfigType, AuthType>,
+    logger: SlateLogger
+  ) {
+    super(input, spec, logger);
+    this.#config = config;
+    this.#auth = auth;
+  }
+
+  get config() {
+    return Object.freeze(this.#config);
+  }
+
+  get auth() {
+    return Object.freeze(this.#auth);
+  }
+}

package/src/context/hook.ts

@@ -1,24 +1,19 @@
 import { AsyncLocalStorage } from 'async_hooks';
-import type { SlateContext } from './context';
+import type { SlateContext, SlatePublicContext } from './context';
 
 let slateContextStorageKey = Symbol.for('slates.provider.context.asyncLocalStorage');
 let globalWithSlateContext = globalThis as typeof globalThis & {
-  [key: symbol]: AsyncLocalStorage<SlateContext<any, any, any>> | undefined;
+  [key: symbol]: AsyncLocalStorage<SlatePublicContext<any>> | undefined;
 };
 
 let asyncLocalStorage =
   globalWithSlateContext[slateContextStorageKey] ??
-  new AsyncLocalStorage<SlateContext<any, any, any>>();
+  new AsyncLocalStorage<SlatePublicContext<any>>();
 
 globalWithSlateContext[slateContextStorageKey] = asyncLocalStorage;
 
-export let runWithContext = <
-  ConfigType extends {},
-  AuthType extends {},
-  InputType extends {},
-  RV
->(
-  context: SlateContext<ConfigType, AuthType, InputType>,
+export let runWithContext = <InputType extends {}, RV>(
+  context: SlatePublicContext<InputType>,
   fn: () => Promise<RV>
 ): Promise<RV> => {
   return asyncLocalStorage.run(context, fn);

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './action';
 export * from './action/attachment';
+export * from './adapter';
 export * from './auth';
 export * from './axios';
 export * from './config';

package/src/specification/slate.ts

@@ -1,4 +1,6 @@
 import type { SlateTool, SlateTrigger } from '../action';
+import type { SlateAdapter } from '../adapter';
+import { SlateDeclarationError } from '../error';
 import type { SlateSpecification } from './specification';
 
 export class Slate<ConfigType extends {}, AuthType extends {}> {
@@ -7,15 +9,45 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
     private readonly _actions: (
       | SlateTrigger<ConfigType, AuthType, any, any>
       | SlateTool<ConfigType, AuthType, any, any>
-    )[]
+    )[],
+    private readonly _adapters: SlateAdapter<ConfigType, AuthType>[]
   ) {}
 
   static create<ConfigType extends {}, AuthType extends {}>(params: {
     spec: SlateSpecification<ConfigType, AuthType>;
     triggers: SlateTrigger<ConfigType, AuthType, any, any>[];
     tools: SlateTool<ConfigType, AuthType, any, any>[];
+    adapters?: SlateAdapter<ConfigType, AuthType>[];
   }) {
-    return new Slate(params.spec, [...params.triggers, ...params.tools]);
+    let adapters = params.adapters ?? [];
+    let actions = [...params.triggers, ...params.tools];
+    let seenAdapterIds = new Set<string>();
+    let seenActionKeys = new Map(actions.map(action => [action.key, action]));
+
+    for (let adapter of adapters) {
+      if (seenAdapterIds.has(adapter.id)) {
+        throw new SlateDeclarationError(
+          `Adapter "${adapter.id}" is registered more than once`
+        );
+      }
+      seenAdapterIds.add(adapter.id);
+
+      for (let action of adapter.actions) {
+        let existing = seenActionKeys.get(action.key);
+        if (existing && existing !== action) {
+          throw new SlateDeclarationError(
+            `Adapter "${adapter.id}" action "${action.key}" conflicts with another action`
+          );
+        }
+
+        if (!existing) {
+          actions.push(action);
+          seenActionKeys.set(action.key, action);
+        }
+      }
+    }
+
+    return new Slate(params.spec, actions, adapters);
   }
 
   get spec() {
@@ -25,4 +57,8 @@ export class Slate<ConfigType extends {}, AuthType extends {}> {
   get actions() {
     return this._actions;
   }
+
+  get adapters() {
+    return this._adapters;
+  }
 }