@ankhorage/contracts 1.10.0 → 1.12.0

package/src/bindings.test.ts

@@ -1,96 +1,316 @@
 import { describe, expect, it } from 'bun:test';
 
 import type {
+  AppManifest,
+  BindingInputMap,
   BindingValueSource,
-  DbCollectionQueryBinding,
-  NodePropBinding,
-  UiNode,
+  ComponentDataBinding,
+  ComponentDataBindingRegistry,
+  EventBinding,
+  PropBinding,
 } from './index';
 
-describe('binding contracts', () => {
-  it('serializes a node prop bound to state', () => {
-    const binding: NodePropBinding = {
-      prop: 'value',
-      valueFrom: {
-        source: 'state',
-        path: 'forms.contact.values.firstname',
-      },
-      transform: 'trim',
-    };
-    const node: UiNode = {
-      id: 'firstname-input',
-      type: 'Input',
+function assertSerializable<TValue>(value: TValue): void {
+  expect(JSON.parse(JSON.stringify(value))).toEqual(value);
+}
+
+describe('component data-binding contracts', () => {
+  it('serializes a component prop bound to an operation response path', () => {
+    const binding: ComponentDataBinding = {
+      componentId: 'hero-title',
+      componentType: 'Text',
       props: {
-        label: 'Firstname',
+        children: {
+          source: {
+            kind: 'operation',
+            operation: {
+              dataSourceId: 'cms',
+              endpointId: 'pages',
+              operationId: 'pages.getHome',
+            },
+            path: '$.data.title',
+          },
+          fallback: {
+            value: 'Untitled',
+          },
+          loading: {
+            state: 'loading',
+            fallback: {
+              value: 'Loading…',
+            },
+          },
+          error: {
+            state: 'error',
+            message: 'Could not load title.',
+            fallback: {
+              value: 'Untitled',
+            },
+          },
+          transforms: ['trim'],
+        },
       },
-      bindings: [binding],
     };
 
-    expect(JSON.parse(JSON.stringify(node))).toEqual(node);
-    expect(node.bindings?.[0]?.valueFrom.source).toBe('state');
+    assertSerializable(binding);
+    expect(binding.props?.children?.source.kind).toBe('operation');
   });
 
-  it('serializes a node prop bound to a DB collection query', () => {
-    const query: DbCollectionQueryBinding = {
-      collection: 'posts',
-      schema: 'public',
-      columns: ['id', 'title', 'published'],
-      filters: [{ field: 'published', operator: 'eq', value: true }],
-      sort: [{ field: 'created_at', direction: 'desc' }],
-      page: { limit: 10, offset: 0 },
-      refresh: 'live',
-    };
-    const node: UiNode = {
-      id: 'posts-list',
-      type: 'CollectionList',
-      bindings: [
-        {
-          prop: 'items',
-          valueFrom: {
-            source: 'db.collection',
-            query,
+  it('serializes literal, context, event, state, and operation value sources', () => {
+    const sources: readonly BindingValueSource[] = [
+      { kind: 'literal', value: { fallback: 'Untitled' } },
+      { kind: 'context', path: 'auth.user.displayName' },
+      { kind: 'event', path: 'payload.values.search' },
+      { kind: 'state', path: 'forms.search.query' },
+      {
+        kind: 'operation',
+        operation: {
+          dataSourceId: 'search-api',
+          operationId: 'search.query',
+        },
+        path: '$.results',
+      },
+    ];
+
+    assertSerializable(sources);
+    expect(sources.map((source) => source.kind)).toEqual([
+      'literal',
+      'context',
+      'event',
+      'state',
+      'operation',
+    ]);
+  });
+
+  it('serializes an event binding that executes a data-source operation', () => {
+    const input: BindingInputMap = {
+      email: {
+        kind: 'source',
+        source: {
+          kind: 'event',
+          path: 'payload.values.email',
+        },
+        transforms: ['trim', 'lowercase'],
+      },
+      message: {
+        kind: 'source',
+        source: {
+          kind: 'event',
+          path: 'payload.values.message',
+        },
+      },
+      source: {
+        kind: 'literal',
+        value: 'contact-form',
+      },
+      metadata: {
+        kind: 'object',
+        fields: {
+          userId: {
+            kind: 'source',
+            source: {
+              kind: 'context',
+              path: 'auth.user.id',
+            },
           },
         },
-      ],
+      },
+    };
+
+    const binding: EventBinding = {
+      target: {
+        kind: 'operation',
+        operation: {
+          dataSourceId: 'contact-api',
+          endpointId: 'messages',
+          operationId: 'messages.create',
+        },
+      },
+      input,
+      when: {
+        source: {
+          kind: 'event',
+          path: 'payload.values.email',
+        },
+        operator: 'exists',
+      },
     };
 
-    expect(JSON.parse(JSON.stringify(node))).toEqual(node);
-    expect(node.bindings?.[0]?.valueFrom.source).toBe('db.collection');
+    assertSerializable(binding);
+    expect(binding.target.kind).toBe('operation');
+    expect(binding.input?.email?.kind).toBe('source');
   });
 
-  it('supports literal, context, and event value sources', () => {
-    const sources: readonly BindingValueSource[] = [
-      { source: 'literal', value: { fallback: 'Untitled' } },
-      { source: 'context', path: 'auth.user.displayName' },
-      { source: 'event', path: 'payload.values.search' },
-    ];
+  it('serializes an event binding that targets a named action', () => {
+    const binding: EventBinding = {
+      target: {
+        kind: 'action',
+        type: 'toast.show',
+      },
+      input: {
+        message: {
+          kind: 'literal',
+          value: 'Saved successfully.',
+        },
+      },
+    };
 
-    expect(JSON.parse(JSON.stringify(sources))).toEqual(sources);
-    expect(sources.map((source) => source.source)).toEqual(['literal', 'context', 'event']);
+    assertSerializable(binding);
+    expect(binding.target.kind).toBe('action');
   });
 
-  it('supports static, focus, poll, and live refresh intent', () => {
-    const refreshModes = ['static', 'focus', 'poll', 'live'] as const;
-    const bindings = refreshModes.map(
-      (refresh): NodePropBinding => ({
-        prop: `items.${refresh}`,
-        valueFrom: {
-          source: 'db.collection',
-          query: {
-            collection: 'posts',
-            refresh,
-            pollIntervalMs: refresh === 'poll' ? 30_000 : undefined,
+  it('serializes component data-binding registries', () => {
+    const bindings: ComponentDataBindingRegistry = {
+      'submit-button': {
+        componentId: 'submit-button',
+        componentType: 'Button',
+        props: {
+          children: {
+            source: {
+              kind: 'literal',
+              value: 'Send',
+            },
+          },
+          disabled: {
+            source: {
+              kind: 'state',
+              path: 'forms.contact.isSubmitting',
+            },
           },
         },
-      }),
-    );
+        events: {
+          press: [
+            {
+              target: {
+                kind: 'operation',
+                operation: {
+                  dataSourceId: 'contact-api',
+                  operationId: 'messages.create',
+                },
+              },
+            },
+          ],
+        },
+      },
+    };
 
-    expect(JSON.parse(JSON.stringify(bindings))).toEqual(bindings);
-    expect(bindings.map((binding) => binding.valueFrom.source)).toEqual([
-      'db.collection',
-      'db.collection',
-      'db.collection',
-      'db.collection',
-    ]);
+    assertSerializable(bindings);
+    expect(bindings['submit-button']?.events?.press?.[0]?.target.kind).toBe('operation');
+  });
+
+  it('serializes app-level dataSources and dataBindings on the manifest', () => {
+    const propBinding: PropBinding = {
+      source: {
+        kind: 'operation',
+        operation: {
+          dataSourceId: 'cms',
+          endpointId: 'pages',
+          operationId: 'pages.getHome',
+        },
+        path: '$.data.heroTitle',
+      },
+    };
+
+    const manifest: AppManifest = {
+      metadata: {
+        name: 'Demo',
+        slug: 'demo',
+        version: '1.0.0',
+        themeId: 'default',
+      },
+      themes: [
+        {
+          id: 'default',
+          name: 'Default',
+          light: {
+            primaryColor: '#3366ff',
+            harmony: 'analogous',
+          },
+          dark: {
+            primaryColor: '#3366ff',
+            harmony: 'analogous',
+          },
+        },
+      ],
+      activeThemeId: 'default',
+      infra: {
+        plugins: [],
+      },
+      navigator: {
+        type: 'stack',
+        routes: [
+          {
+            name: 'home',
+            screenId: 'home',
+          },
+        ],
+      },
+      screens: {
+        home: {
+          id: 'home',
+          name: 'Home',
+          root: {
+            id: 'screen-root',
+            type: 'Screen',
+            children: [
+              {
+                id: 'hero-title',
+                type: 'Text',
+              },
+            ],
+          },
+        },
+      },
+      dataSources: {
+        cms: {
+          id: 'cms',
+          kind: 'rest',
+          baseUrl: 'https://cms.example.com',
+          endpoints: {
+            pages: {
+              id: 'pages',
+              kind: 'http',
+              path: '/pages/home',
+              operations: {
+                'pages.getHome': {
+                  id: 'pages.getHome',
+                  endpointId: 'pages',
+                  protocol: 'http',
+                  intent: 'read',
+                  method: 'GET',
+                  path: '/pages/home',
+                },
+              },
+            },
+          },
+        },
+      },
+      dataBindings: {
+        'hero-title': {
+          componentId: 'hero-title',
+          componentType: 'Text',
+          props: {
+            children: propBinding,
+          },
+        },
+      },
+      settings: {
+        localization: {
+          defaultLocale: 'en',
+          locales: ['en'],
+        },
+        authFlow: {
+          signInRoute: '/sign-in',
+          signUpRoute: '/sign-up',
+          signOutRoute: '/sign-out',
+          forgotPasswordRoute: '/forgot-password',
+          postSignInRoute: '/',
+          unauthorizedRoute: '/sign-in',
+        },
+      },
+    };
+
+    assertSerializable(manifest);
+    expect(manifest.dataBindings?.['hero-title']?.props?.children?.source.kind).toBe('operation');
+    expect(manifest.dataSources?.cms?.kind).toBe('rest');
   });
 });

package/src/bindings.ts

@@ -1,4 +1,7 @@
-import type { DbFilter, DbPage, DbSort } from './db';
+import type { DataSourceId, EndpointId, OperationId } from './data';
+
+export type ComponentInstanceId = string;
+export type ComponentTypeId = string;
 
 export type BindingValue =
   | string
@@ -10,45 +13,118 @@ export type BindingValue =
       readonly [key: string]: BindingValue;
     };
 
-export type BindingRefreshMode = 'focus' | 'live' | 'poll' | 'static';
+export type BindingDataPath = string;
+
+export type BindingValueTransform = 'lowercase' | 'trim' | 'uppercase';
 
-export interface DbCollectionQueryBinding {
-  readonly collection: string;
-  readonly schema?: string;
-  readonly columns?: readonly string[];
-  readonly filters?: readonly DbFilter[];
-  readonly sort?: readonly DbSort[];
-  readonly page?: DbPage;
-  readonly refresh?: BindingRefreshMode;
-  readonly pollIntervalMs?: number;
+export interface BindingOperationRef {
+  readonly dataSourceId: DataSourceId;
+  readonly operationId: OperationId;
+  readonly endpointId?: EndpointId;
 }
 
 export type BindingValueSource =
   | {
-      readonly source: 'context';
-      readonly path: string;
+      readonly kind: 'context';
+      readonly path: BindingDataPath;
     }
   | {
-      readonly source: 'db.collection';
-      readonly query: DbCollectionQueryBinding;
+      readonly kind: 'event';
+      readonly path: BindingDataPath;
     }
   | {
-      readonly source: 'event';
-      readonly path: string;
+      readonly kind: 'literal';
+      readonly value: BindingValue;
+    }
+  | {
+      readonly kind: 'operation';
+      readonly operation: BindingOperationRef;
+      readonly path?: BindingDataPath;
+    }
+  | {
+      readonly kind: 'state';
+      readonly path: BindingDataPath;
+    };
+
+export interface BindingValueExpression {
+  readonly source: BindingValueSource;
+  readonly transforms?: readonly BindingValueTransform[];
+}
+
+export interface BindingFallback {
+  readonly value?: BindingValue;
+  readonly source?: BindingValueSource;
+}
+
+export type BindingLifecycleState = 'empty' | 'error' | 'loading';
+
+export interface BindingLifecycleBehavior {
+  readonly state: BindingLifecycleState;
+  readonly fallback?: BindingFallback;
+  readonly message?: string;
+}
+
+export interface PropBinding {
+  readonly source: BindingValueSource;
+  readonly fallback?: BindingFallback;
+  readonly loading?: BindingLifecycleBehavior;
+  readonly error?: BindingLifecycleBehavior;
+  readonly empty?: BindingLifecycleBehavior;
+  readonly transforms?: readonly BindingValueTransform[];
+}
+
+export type BindingInputValue =
+  | {
+      readonly kind: 'array';
+      readonly items: readonly BindingInputValue[];
     }
   | {
-      readonly source: 'literal';
+      readonly kind: 'literal';
       readonly value: BindingValue;
     }
   | {
-      readonly source: 'state';
-      readonly path: string;
+      readonly kind: 'object';
+      readonly fields: Readonly<Record<string, BindingInputValue>>;
+    }
+  | {
+      readonly kind: 'source';
+      readonly source: BindingValueSource;
+      readonly transforms?: readonly BindingValueTransform[];
     };
 
-export type BindingValueTransform = 'lowercase' | 'trim' | 'uppercase';
+export type BindingInputMap = Readonly<Record<string, BindingInputValue>>;
+
+export type BindingConditionOperator = 'eq' | 'exists' | 'neq' | 'notExists';
 
-export interface NodePropBinding {
-  readonly prop: string;
-  readonly valueFrom: BindingValueSource;
-  readonly transform?: BindingValueTransform | readonly BindingValueTransform[];
+export interface BindingCondition {
+  readonly source: BindingValueSource;
+  readonly operator: BindingConditionOperator;
+  readonly value?: BindingValue;
 }
+
+export type EventBindingTarget =
+  | {
+      readonly kind: 'action';
+      readonly type: string;
+    }
+  | {
+      readonly kind: 'operation';
+      readonly operation: BindingOperationRef;
+    };
+
+export interface EventBinding {
+  readonly target: EventBindingTarget;
+  readonly input?: BindingInputMap;
+  readonly when?: BindingCondition;
+}
+
+export interface ComponentDataBinding {
+  readonly componentId: ComponentInstanceId;
+  readonly componentType?: ComponentTypeId;
+  readonly props?: Readonly<Record<string, PropBinding>>;
+  readonly events?: Readonly<Record<string, readonly EventBinding[]>>;
+}
+
+export type ComponentDataBindingRegistry = Readonly<
+  Record<ComponentInstanceId, ComponentDataBinding>
+>;