@process.co/element-types 0.0.17 → 0.0.19

package/src/define-action.test-d.ts

@@ -0,0 +1,69 @@
+/**
+ * Compile-only checks for defineAction (not emitted).
+ */
+import {
+    defineAction,
+    defineApp,
+    type ActionRunOptions,
+    type DeriveActionInstance,
+    type DeriveEmbeddedAppPropInstance,
+} from './index';
+
+const httpApp = defineApp({
+    type: 'app',
+    app: 'http',
+    propDefinitions: {
+        httpRequest: { type: 'http_request', label: 'HTTP Request' },
+    },
+} as const);
+
+const _action = defineAction({
+    type: 'action',
+    key: 'test-action',
+    version: '1.0.0',
+    props: {
+        label: { type: 'string', default: '' },
+        http: httpApp,
+    },
+    methods: {
+        async run({ $, steps }) {
+            void steps;
+            $.export('out', {});
+            void $.flow;
+            this.label;
+            this.http.httpRequest.execute;
+        },
+    },
+});
+
+export type _actionType = typeof _action;
+
+type _runParams = Parameters<NonNullable<typeof _action.methods>['run']>[0];
+type _runDollar = _runParams['$'];
+type _assertRunDollar = _runDollar extends ActionRunOptions['$'] ? true : false;
+const _runDollarCheck: _assertRunDollar = true;
+
+type _httpOnThis = DeriveActionInstance<typeof _action>['http'];
+type _httpRuntime = DeriveEmbeddedAppPropInstance<typeof httpApp>;
+type _assertHttpProp = _httpOnThis extends _httpRuntime ? true : false;
+const _httpPropCheck: _assertHttpProp = true;
+type _assertNotDefinition = 'type' extends keyof _httpOnThis ? false : true;
+const _notDefinitionCheck: _assertNotDefinition = true;
+type _assertRunOnThis = typeof _action.methods.run extends DeriveActionInstance<typeof _action>['run']
+    ? true
+    : false;
+const _runOnThisCheck: _assertRunOnThis = true;
+
+/** @deprecated top-level `run` — still accepted for older elements. */
+const _legacyTopLevelRun = defineAction({
+    type: 'action',
+    key: 'legacy-run',
+    version: '1.0.0',
+    props: {},
+    async run({ $, steps }) {
+        void steps;
+        $.export('legacy', true);
+    },
+});
+
+void _legacyTopLevelRun;

package/src/define-signal-app-prop.test-d.ts

@@ -0,0 +1,44 @@
+/**
+ * Compile-only: embedded `defineApp` in signal `props` (not emitted).
+ */
+import {
+    defineApp,
+    defineSignal,
+    type DeriveEmbeddedAppPropInstance,
+    type DeriveSignalInstance,
+} from './index';
+
+const httpApp = defineApp({
+    type: 'app',
+    app: 'http',
+    noAuth: true,
+    propDefinitions: {
+        httpRequest: {
+            type: 'http_request',
+            label: 'HTTP Request Configuration',
+        },
+    },
+} as const);
+
+const _signal = defineSignal({
+    type: 'signal',
+    props: {
+        httpInterface: { type: '$.interface.http' },
+        http: httpApp,
+    },
+    async run() {
+        this.http.httpRequest.execute;
+        this.httpInterface.deferHttpResponse;
+    },
+});
+
+export type _HttpOnThis = DeriveSignalInstance<typeof _signal>['http'];
+export type _HttpRuntime = DeriveEmbeddedAppPropInstance<typeof httpApp>;
+type _assertHttpProp = _HttpOnThis extends _HttpRuntime ? true : false;
+const _httpPropCheck: _assertHttpProp = true;
+type _assertNotDefinition = 'type' extends keyof _HttpOnThis ? false : true;
+const _notDefinitionCheck: _assertNotDefinition = true;
+type _assertHttpRequest = _HttpOnThis['httpRequest'] extends { execute: () => Promise<unknown> }
+    ? true
+    : false;
+const _httpRequestCheck: _assertHttpRequest = true;

package/src/define-signal-hook-this.test-d.ts

@@ -0,0 +1,47 @@
+/**
+ * Compile-only checks for defineSignal hook vs run `this` (not emitted).
+ */
+import {
+    defineSignal,
+    type SignalRunHostServices,
+    type SignalSaveHostParameters,
+} from './index';
+
+const _webhook = defineSignal({
+    type: 'signal',
+    props: {
+        httpInterface: { type: '$.interface.http' },
+        cacheMaxAge: { type: '$.interface.duration', default: 86400 },
+        authType: { type: 'string', default: 'none' },
+    },
+    hooks: {
+        async save({ $ }) {
+            await $.http.configureResponseCaching({
+                maxAge: this.cacheMaxAge,
+                varyBy: '*',
+            });
+            // @ts-expect-error — `run` host `$` is not available in hooks.save
+            $.enforceSchema;
+            // @ts-expect-error — `$emit` is only on `run` `this`, not hooks
+            this.$emit;
+            // @ts-expect-error — no runtime HTTP interface on hook `this`
+            await this.httpInterface.respond({ status: 200, body: {} });
+        },
+    },
+    async run({ $, event }) {
+        void event;
+        $.enforceSchema;
+        // @ts-expect-error — save-only host `$` is not available in run
+        $.http;
+        await this.httpInterface.deferHttpResponse(30_000);
+    },
+});
+
+export type _webhookType = typeof _webhook;
+
+type _saveParams = Parameters<NonNullable<typeof _webhook.hooks>['save']>[0];
+type _saveDollar = _saveParams['$'];
+type _assertSaveDollar = _saveDollar extends SignalSaveHostParameters['$'] ? true : false;
+const _saveDollarCheck: _assertSaveDollar = true;
+type _saveDollarNotRun = SignalRunHostServices extends _saveDollar ? false : true;
+const _saveDollarNotRunCheck: _saveDollarNotRun = true;

package/src/http-request-cache.ts

@@ -0,0 +1,56 @@
+/**
+ * HTTP response replay cache — policy at save, vary key at runtime.
+ */
+
+export type HttpRequestCacheMode = 'cache-only' | 'stale-while-revalidate';
+
+/** Materialized at save → elementData.$httpRequestCachePolicy */
+export type HttpRequestCachePolicy = {
+    mode: HttpRequestCacheMode;
+    ttlSeconds: number;
+    refreshAfterSeconds?: number;
+    vary: HttpRequestCacheVary;
+    /** When true, webhook loads trigger so author can call setRequestVaryKey. */
+    needsRuntimeVaryKey?: boolean;
+};
+
+export type HttpRequestCacheVary = {
+    headers?: Array<{ name: string; lowerCase?: boolean }>;
+    clientIp?: boolean;
+    pathTemplate?: string;
+    query?: string[];
+    body?: BodyVaryProjection;
+};
+
+/** Boolean leaves select fields; nested objects recurse. */
+export type BodyVaryProjection = {
+    [key: string]: boolean | BodyVaryProjection;
+};
+
+/** Editor wire for $.interface.cacheVaryInfo */
+export type CacheVaryInfoWire = {
+    headers?: Array<{ name: string }>;
+    query?: string[];
+    clientIp?: boolean;
+    pathTemplate?: string;
+    bodyPaths?: BodyVaryProjection;
+    customRuntimeKey?: boolean;
+};
+
+/** Seconds (TTL). $.interface.duration */
+export type DurationWire = number;
+
+/** Save-only: hooks.save → $.http.configureResponseCaching */
+export type ConfigureResponseCachingOptions = {
+    maxAge: number;
+    varyBy: HttpRequestCacheVary | CacheVaryInfoWire | '*' | string[];
+    mode?: HttpRequestCacheMode;
+    refreshAfterSeconds?: number;
+    needsRuntimeVaryKey?: boolean;
+};
+
+export const HTTP_REQUEST_CACHE_POLICY_KEY = '$httpRequestCachePolicy' as const;
+
+export const REPLAY_BINDING_RANGE = '$replayBinding' as const;
+
+export const REPLAY_META_RANGE = '$replayMeta' as const;