Elb

Author: alexanderkirtzel

packages/sources/node/src/index.ts

@@ -1,4 +1,4 @@
-import type { SourceNode } from './types';
+import type { Elb, SourceNode } from './types';
 import { handleCommand, handleEvent } from './lib/handle';
 import { run } from './lib/run';
 import { getState } from './lib/state';
@@ -22,7 +22,7 @@ export function sourceNode(
   const instance: SourceNode.Instance = {
     version,
     ...state,
-    push: (() => {}) as unknown as SourceNode.Elb, // Placeholder for the actual push function
+    push: (() => {}) as unknown as Elb.Fn, // Placeholder for the actual push function
   };
 
   // Overwrite the push function with the instance-reference

packages/sources/node/src/lib/handle.ts

@@ -1,5 +1,5 @@
 import type { WalkerOS } from '@elbwalker/types';
-import type { SourceNode, DestinationNode } from '../types';
+import type { Elb, SourceNode } from '../types';
 import { Const, assign, isObject, isSameType } from '@elbwalker/utils';
 import { addDestination } from './destination';
 import { pushToDestinations } from './push';
@@ -14,9 +14,7 @@ export const handleCommand: SourceNode.HandleCommand = async (
   data?,
   options?,
 ) => {
-  let result:
-    | Partial<SourceNode.PushResult | DestinationNode.PushResult>
-    | undefined = {};
+  let result: Partial<Elb.PushResult> | undefined = {};
 
   switch (action) {
     case Const.Commands.Config:

packages/sources/node/src/lib/helper.ts

@@ -1,10 +1,10 @@
-import type { SourceNode } from '../types';
+import type { Elb } from '../types';
 import { Const, assign } from '@elbwalker/utils';
 
 export function createResult(
-  partialResult?: Partial<SourceNode.PushResult>,
-): SourceNode.PushResult {
-  const result: SourceNode.PushResult = assign(
+  partialResult?: Partial<Elb.PushResult>,
+): Elb.PushResult {
+  const result: Elb.PushResult = assign(
     {
       successful: [],
       queued: [],

packages/sources/node/src/lib/push.ts

@@ -1,5 +1,5 @@
 import type { WalkerOS } from '@elbwalker/types';
-import type { SourceNode, DestinationNode } from '../types';
+import type { SourceNode, DestinationNode, Elb } from '../types';
 import {
   assign,
   getGrantedConsent,
@@ -15,13 +15,13 @@ export function createPush(
   instance: SourceNode.Instance,
   handleCommand: SourceNode.HandleCommand,
   handleEvent: SourceNode.HandleEvent,
-): SourceNode.Elb {
-  const push: SourceNode.Elb = async (
+): Elb.Fn<Promise<Elb.PushResult>> {
+  const push = async (
     nameOrEvent: string | WalkerOS.DeepPartialEvent,
-    data?: SourceNode.PushData,
-    options?: SourceNode.PushOptions,
-  ): Promise<SourceNode.PushResult> => {
-    let result: SourceNode.PushResult = {
+    data?: Elb.PushData,
+    options?: Elb.PushOptions,
+  ) => {
+    let result: Elb.PushResult = {
       status: { ok: false },
       successful: [],
       queued: [],
@@ -31,9 +31,9 @@ export function createPush(
     return await tryCatchAsync(
       async (
         nameOrEvent: string | WalkerOS.DeepPartialEvent,
-        data?: SourceNode.PushData,
-        options?: SourceNode.PushOptions,
-      ): Promise<SourceNode.PushResult> => {
+        data?: Elb.PushData,
+        options?: Elb.PushOptions,
+      ): Promise<Elb.PushResult> => {
         const { event, command } = createEventOrCommand(
           instance,
           nameOrEvent,

packages/sources/node/src/types/elb.ts

@@ -0,0 +1,31 @@
+import type { Elb, WalkerOS } from '@elbwalker/types';
+import { DestinationNode, SourceNode } from '.';
+
+export interface Fn<R = Promise<PushResult>>
+  extends Elb.Fn<R>,
+    Parameters<R>,
+    Event<R> {}
+
+export type Parameters<R = Promise<PushResult>> = (
+  name: string,
+  data?: PushData,
+  options?: PushOptions,
+) => R;
+
+export type Event<R = Promise<PushResult>> = (
+  event: WalkerOS.DeepPartialEvent,
+  data?: PushData,
+  options?: PushOptions,
+) => R;
+
+export type PushData =
+  | Elb.PushData
+  | DestinationNode.Destination
+  | Partial<SourceNode.State>;
+
+export type PushOptions = Elb.PushOptions | DestinationNode.Config;
+
+export interface PushResult extends DestinationNode.PushResult {
+  event?: WalkerOS.Event;
+  status: SourceNode.Status;
+}

packages/sources/node/src/types/index.ts

@@ -1,3 +1,4 @@
 export * as DestinationNode from './destination';
+export * as Elb from './elb';
 export * as On from './on';
 export * as SourceNode from './source';

packages/sources/node/src/types/source.ts

@@ -1,11 +1,11 @@
 import type { WalkerOS, Schema, Handler, Hooks } from '@elbwalker/types';
-import type { DestinationNode, On } from '.';
+import type { DestinationNode, Elb, On } from '.';
 
 export interface Instance extends State, WalkerOS.Instance {
   config: Config;
   destinations: Destinations;
   version: string;
-  push: Elb<Promise<PushResult>>;
+  push: Elb.Fn;
 }
 
 export interface State extends WalkerOS.State {
@@ -39,34 +39,17 @@ export interface AddDestination {
   (id: string, destination: DestinationNode.Destination): void;
 }
 
-export interface Elb<R = Promise<PushResult>> extends WalkerOS.Elb<R> {
-  (name: string, data?: PushData, options?: PushOptions): R;
-  (event: WalkerOS.PartialEvent, data?: PushData, options?: PushOptions): R;
-}
-
 export type HandleCommand = (
   instance: Instance,
   action: string,
-  data?: PushData,
-  options?: PushOptions,
-) => Promise<PushResult>;
+  data?: Elb.PushData,
+  options?: Elb.PushOptions,
+) => Promise<Elb.PushResult>;
 
 export type HandleEvent = (
   instance: Instance,
   event: WalkerOS.Event,
-) => Promise<PushResult>;
-
-export type PushData =
-  | WalkerOS.PushData
-  | DestinationNode.Destination
-  | Partial<State>;
-
-export type PushOptions = WalkerOS.PushOptions | DestinationNode.Config;
-
-export interface PushResult extends DestinationNode.PushResult {
-  event?: WalkerOS.Event;
-  status: Status;
-}
+) => Promise<Elb.PushResult>;
 
 export interface Command {
   name: string;

packages/sources/walkerjs/src/types/elb.ts

@@ -1,9 +1,9 @@
 import type { Elb, WalkerOS } from '@elbwalker/types';
-import { State } from './source';
-import type { On, DestinationWeb, Walker } from '.';
+import type { On, DestinationWeb, Walker, SourceWalkerjs } from '.';
 
 export interface Fn<R = void>
-  extends CommandInit<R>,
+  extends Elb.Fn<R>,
+    CommandInit<R>,
     CommandDestination<R>,
     CommandRun<R>,
     CommandOn<R>,
@@ -23,7 +23,7 @@ export type CommandDestination<R = void> = (
 
 export type CommandRun<R = void> = (
   event: 'walker run',
-  state?: Partial<State>,
+  state?: Partial<SourceWalkerjs.State>,
 ) => R;
 
 export type CommandOn<R = void> = (
@@ -56,7 +56,7 @@ export type PushData =
   | Elb.PushData
   | DestinationWeb.Destination
   | DestinationWeb.DestinationInit
-  | Partial<State>
+  | Partial<SourceWalkerjs.State>
   | ScopeType;
 
 export type PushOptions =