@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/integrations/index.js

@@ -0,0 +1,24 @@
+/**
+ * Integrations (headless spec §9.2): the store's connections to other systems. The data
+ * pipelines' source connections, connectors and import and export set-ups, the e-mail marketing
+ * connection (`esp`), the AFAS Profit connection with what is sent to it (`afas`) and the Exact
+ * Online connection with its settings (`exactOnline`); the pipelines themselves, their runs and
+ * their progress streams follow in phase 7.
+ */
+import { createAfasModule } from './afas.js';
+import { createEspModule } from './esp.js';
+import { createExactOnlineModule } from './exact-online.js';
+import { createIntegrationPipelinesModule } from './pipelines.js';
+export { AFAS_SYNC_LOG_PAGE_LIMIT } from './afas.js';
+export { AFAS_CUSTOMER_SEARCH_LIMIT } from './afas-actions.js';
+export { PIPELINE_CONNECTION_PRESERVE_KEYS } from './connections.js';
+export { ESP_BACKFILL_RESOURCES, ESP_SYNC_LOG_PAGE_LIMIT } from './esp.js';
+export { PIPELINE_DRAFT_PRESERVE_KEYS, PIPELINE_DRAFT_SLOW_TIMEOUT_MS } from './pipelines.js';
+export function createIntegrationsModule(transport) {
+    return {
+        pipelines: createIntegrationPipelinesModule(transport),
+        esp: createEspModule(transport),
+        afas: createAfasModule(transport),
+        exactOnline: createExactOnlineModule(transport),
+    };
+}

package/dist/integrations/pipeline-keys.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Every key whose VALUE is stored data, not DTO shape: the platform's passthrough set
+ * (`credentials`, `public_credentials`, `site_analysis`, `trigger_filter`, …) plus a schema map's
+ * jsonb columns, which carry the source's own field names and sample records. Converting them
+ * would rename a sample's `date_created` to `dateCreated`, and a `triggerFilter`'s `toState` would
+ * reach the reader as `to_state`, which it ignores.
+ */
+export declare const PIPELINE_DRAFT_PRESERVE_KEYS: ReadonlySet<string>;
+/**
+ * A creation probes the source over the network, and a commit creates the pipeline and may start
+ * its run: both outlast the SDK's 15-second default on a slow source.
+ */
+export declare const PIPELINE_DRAFT_SLOW_TIMEOUT_MS = 60000;

package/dist/integrations/pipeline-keys.js

@@ -0,0 +1,22 @@
+import { PLATFORM_PASSTHROUGH_KEYS } from '@sixtyninecommerce/core';
+/**
+ * Every key whose VALUE is stored data, not DTO shape: the platform's passthrough set
+ * (`credentials`, `public_credentials`, `site_analysis`, `trigger_filter`, …) plus a schema map's
+ * jsonb columns, which carry the source's own field names and sample records. Converting them
+ * would rename a sample's `date_created` to `dateCreated`, and a `triggerFilter`'s `toState` would
+ * reach the reader as `to_state`, which it ignores.
+ */
+export const PIPELINE_DRAFT_PRESERVE_KEYS = new Set([
+    ...PLATFORM_PASSTHROUGH_KEYS,
+    'source_schema',
+    'sourceSchema',
+    'target_schema',
+    'targetSchema',
+    'sub_counts',
+    'subCounts',
+]);
+/**
+ * A creation probes the source over the network, and a commit creates the pipeline and may start
+ * its run: both outlast the SDK's 15-second default on a slow source.
+ */
+export const PIPELINE_DRAFT_SLOW_TIMEOUT_MS = 60_000;

package/dist/integrations/pipelines.d.ts

@@ -0,0 +1,114 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+import { type PipelineConnectionsModule } from './connections.js';
+import type { CommittedPipelineDraft, ImportDependency, PipelineConnector, PipelineDirection, PipelineDraft, PipelineDraftSummary, UpdatePipelineDraftInput, UpdatePipelineDraftSchemaMapInput } from './types.js';
+export { PIPELINE_DRAFT_PRESERVE_KEYS, PIPELINE_DRAFT_SLOW_TIMEOUT_MS } from './pipeline-keys.js';
+/**
+ * Half-finished import and export set-ups, kept on the server for the store (headless spec §7).
+ *
+ * - **Any admin of the store with pipeline rights (`UpdateCatalog`) continues a draft, from any
+ *   device.** Drafts belong to the store, not to the person who started one: the list shows every
+ *   unfinished set-up of the active store, and another store's draft is `PIPELINE_DRAFT_NOT_FOUND`.
+ * - **Kept 7 days after its LAST change.** Every write moves `expiresAt`; reads do not. An expired
+ *   draft answers `PIPELINE_DRAFT_NOT_FOUND` at once, and the platform then deletes it together
+ *   with the connection (and its stored password) the draft created, unless a pipeline or another
+ *   draft uses that connection. A connection that existed before any draft is never deleted; one
+ *   another draft created is the picking draft's too (`connection.createdByDraft`), and goes when
+ *   the last draft holding it lets go of it unused.
+ * - **A draft never holds a secret.** Credentials go to {@link PipelineDraftsModule.connect} only,
+ *   which creates the connection and stores them there, encrypted. A set-up resumed before its
+ *   connection exists asks for the credentials again; the source URL and the other settings are
+ *   kept.
+ * - **Every change names the `version` it was made against** and answers the draft with the next
+ *   one. A change made on an older version is refused with a `ConflictError` coded
+ *   `PIPELINE_DRAFT_CONFLICT` (409) and changes nothing: another admin, or another tab, changed it
+ *   first. Read it again and reapply.
+ * - What a step still needs is a `BusinessRuleError` coded `PIPELINE_DRAFT_INCOMPLETE` (422) whose
+ *   `details[]` name each field; a change the set-up refuses (a step of the other direction, a
+ *   connector that cannot work in it) is a `ValidationError` coded `PIPELINE_DRAFT_INVALID` (400).
+ * - An organization workspace is not a store and is refused every door; an app below
+ *   `customerData: full` is too, and `connect` refuses every app (`APP_CREDENTIAL_NOT_ALLOWED`).
+ */
+export interface PipelineDraftsModule {
+    /** The store's unexpired drafts, newest first. */
+    list(options?: ListOptions): Promise<Page<PipelineDraftSummary>>;
+    /**
+     * One draft with its connection, discovery status, schema maps, the served dependencies and their
+     * warnings, and the name the configure step would suggest in the store's zone. Poll it while
+     * `discovery.status` is `pending` or `running`.
+     */
+    get(id: string, options?: Call): Promise<PipelineDraft>;
+    /** Start a set-up. The schedule zone starts as the store's, and the step is `connector`. */
+    create(input: {
+        direction: PipelineDirection;
+    }, options?: Call): Promise<PipelineDraft>;
+    /**
+     * Change fields. `connectorType` starts the connection over (no source URL, connection,
+     * discovery or stock location), even for the same connector; `direction` alone moves to the
+     * connector step; entering `configure` with no name gives the default one. A credential is
+     * refused here (400): send it to {@link PipelineDraftsModule.connect}.
+     */
+    update(id: string, input: UpdatePipelineDraftInput, options?: Call): Promise<PipelineDraft>;
+    /**
+     * Create the draft's connection from its connector, source URL, throttle and legacy hosts, plus
+     * the `credentials` sent now: the source is probed first (a failed probe saves nothing), then
+     * the credentials are stored encrypted ON THE CONNECTION, never on the draft. The draft then
+     * owns the connection, so discarding or expiring it deletes the connection too. A previous
+     * connection the draft created, and its discovery, are let go.
+     */
+    connect(id: string, input: {
+        version: number;
+        credentials: Record<string, string>;
+    }, options?: Call): Promise<PipelineDraft>;
+    /**
+     * Use one of the store's existing connections. Discarding the draft never deletes a connection
+     * that existed before any draft; one another draft created and still holds is this draft's too
+     * (`connection.createdByDraft` says so), and the last draft to let go of it unused deletes it.
+     */
+    useConnection(id: string, input: {
+        version: number;
+        connectionId: string;
+    }, options?: Call): Promise<PipelineDraft>;
+    /** Start the discovery of an import draft's connection; poll {@link PipelineDraftsModule.get}. */
+    discover(id: string, input: {
+        version: number;
+    }, options?: Call): Promise<PipelineDraft>;
+    /** Change one schema map of the draft's discovery. */
+    updateSchemaMap(id: string, entityType: string, input: UpdatePipelineDraftSchemaMapInput, options?: Call): Promise<PipelineDraft>;
+    /**
+     * Save the draft as a pipeline and delete the draft; with `startRun` also start its first run.
+     * A run that does not start leaves the pipeline in place and answers `runError`. Takes an
+     * `idempotencyKey`: a commit retried after a lost answer replays the first one.
+     */
+    commit(id: string, input: {
+        version: number;
+        startRun?: boolean;
+    }, options?: Call): Promise<CommittedPipelineDraft>;
+    /**
+     * Delete the draft, and the connection it created with its stored password unless a pipeline
+     * or another draft uses it.
+     */
+    discard(id: string, options?: Call): Promise<void>;
+}
+/** Data pipelines (imports and exports between the store and another system). */
+export interface IntegrationPipelinesModule {
+    drafts: PipelineDraftsModule;
+    /** The store's source connections. See {@link PipelineConnectionsModule}. */
+    connections: PipelineConnectionsModule;
+    /**
+     * The connectors this deployment offers, `coming_soon` ones included: each one's credential
+     * form (`credentialFields`), what its stored secrets are bound to (`credentialBinding`) and
+     * what it can import and export. Needs `ReadCatalog`.
+     *
+     * @effect read
+     */
+    connectors(options?: Call): Promise<PipelineConnector[]>;
+    /**
+     * What each importable entity type needs imported first, from the import writers themselves
+     * (the warnings' data; the words are yours).
+     *
+     * @effect read
+     */
+    importDependencies(options?: Call): Promise<ImportDependency[]>;
+}
+export declare function createIntegrationPipelinesModule(transport: Transport): IntegrationPipelinesModule;

package/dist/integrations/pipelines.js

@@ -0,0 +1,46 @@
+import { createPage, readRestPage } from '@sixtyninecommerce/core';
+import { createPipelineConnectionsModule, listPipelineConnectors, } from './connections.js';
+import { PIPELINE_DRAFT_PRESERVE_KEYS, PIPELINE_DRAFT_SLOW_TIMEOUT_MS } from './pipeline-keys.js';
+export { PIPELINE_DRAFT_PRESERVE_KEYS, PIPELINE_DRAFT_SLOW_TIMEOUT_MS } from './pipeline-keys.js';
+const DRAFTS = '/pipelines/drafts';
+const segment = (value) => encodeURIComponent(value);
+export function createIntegrationPipelinesModule(transport) {
+    const read = (path, options) => transport.rest('plugins', { method: 'GET', path }, { ...options, preserveKeys: PIPELINE_DRAFT_PRESERVE_KEYS });
+    const write = (method, path, body, options, timeoutMs) => transport.rest('plugins', { method, path, body }, {
+        ...options,
+        preserveKeys: PIPELINE_DRAFT_PRESERVE_KEYS,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    });
+    async function list(options) {
+        const body = await transport.rest('plugins', {
+            method: 'GET',
+            path: DRAFTS,
+            query: { after: options?.after, limit: options?.limit },
+        }, { ...options, preserveKeys: PIPELINE_DRAFT_PRESERVE_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => list({ ...options, after: cursor }));
+    }
+    const drafts = {
+        list,
+        get: (id, options) => read(`${DRAFTS}/${segment(id)}`, options),
+        create: (input, options) => write('POST', DRAFTS, input, options),
+        update: (id, input, options) => write('PATCH', `${DRAFTS}/${segment(id)}`, input, options),
+        connect: (id, input, options) => write('POST', `${DRAFTS}/${segment(id)}/connection`, input, options, PIPELINE_DRAFT_SLOW_TIMEOUT_MS),
+        useConnection: (id, input, options) => write('POST', `${DRAFTS}/${segment(id)}/connection/existing`, input, options),
+        discover: (id, input, options) => write('POST', `${DRAFTS}/${segment(id)}/discover`, input, options),
+        updateSchemaMap: (id, entityType, input, options) => write('PATCH', `${DRAFTS}/${segment(id)}/schema-maps/${segment(entityType)}`, input, options),
+        commit: (id, input, options) => write('POST', `${DRAFTS}/${segment(id)}/commit`, input, options, PIPELINE_DRAFT_SLOW_TIMEOUT_MS),
+        async discard(id, options) {
+            await transport.rest('plugins', { method: 'DELETE', path: `${DRAFTS}/${segment(id)}`, expect: 'void' }, options);
+        },
+    };
+    return {
+        drafts,
+        connections: createPipelineConnectionsModule(transport),
+        connectors: (options) => listPipelineConnectors(transport, options),
+        async importDependencies(options) {
+            const body = await read('/pipelines/import-dependencies', options);
+            return body.data;
+        },
+    };
+}

package/dist/integrations/types.d.ts

@@ -0,0 +1,322 @@
+/**
+ * The shapes of `admin.integrations.pipelines` (headless spec §7 `pipelines.drafts`).
+ *
+ * Kept verbatim (stored data, never renamed): `triggerFilter`'s keys (reader field names such as
+ * `toState`), `siteAnalysis` and `publicCredentials` (the connector's own keys), and a schema
+ * map's `sourceSchema`, `targetSchema` and `subCounts`.
+ */
+export type PipelineDirection = 'import' | 'export';
+/** The wizard's steps before a commit; `import`/`done` come after one, when no draft exists. */
+export type PipelineDraftStep = 'direction' | 'connector' | 'credentials' | 'discovery' | 'review' | 'entities' | 'trigger' | 'configure' | 'preview';
+export type PipelineSyncPolicy = 'preserve_local' | 'always_source';
+export type PipelineScheduleType = 'one_time' | 'daily' | 'weekly' | 'custom';
+export type PipelineTriggerType = 'manual' | 'scheduled';
+/** One draft in the store's list. */
+export interface PipelineDraftSummary {
+    id: string;
+    direction: PipelineDirection;
+    step: PipelineDraftStep;
+    connectorType: string | null;
+    /** The pipeline's name, once the configure step gave it one. */
+    name: string | null;
+    connectionId: string | null;
+    discoveryId: string | null;
+    /** Send it back with the next change; a change made on an older one is refused 409. */
+    version: number;
+    /** Vendure User.id of whoever started it (an API token's own administrator for a token). */
+    createdByUserId: string;
+    updatedByUserId: string;
+    createdAt: string;
+    updatedAt: string;
+    /** 7 days after the last change; the draft answers 404 from then on. */
+    expiresAt: string;
+}
+/** The connection a draft holds. Never a credential: `publicCredentials` holds non-password fields only. */
+export interface PipelineDraftConnection {
+    id: string;
+    name: string;
+    connectorType: string;
+    sourceUrl: string;
+    status: string;
+    /** Soft-deleted on the Connections page since the draft took it: connect again. */
+    removed: boolean;
+    /** The draft (or another draft holding it) created it, so discarding the draft deletes it. */
+    createdByDraft: boolean;
+    siteAnalysis: Record<string, unknown> | null;
+    publicCredentials: Record<string, string> | null;
+    lastTestedAt: string | null;
+}
+export interface PipelineDraftDiscovery {
+    id: string;
+    /** `pending` → `running` → `completed` | `failed`. Poll the draft to follow it. */
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    source: string;
+    errorMessage: string | null;
+    warnings: string[];
+    detectedPlugins: string[];
+    startedAt: string | null;
+    completedAt: string | null;
+}
+export interface PipelineDraftFieldMapping {
+    sourceField: string;
+    sourcePath: string;
+    targetField: string;
+    targetPath: string;
+    transform: string | null;
+    confidence: number;
+    enabled: boolean;
+}
+export interface PipelineDraftSchemaMap {
+    id: string;
+    entityType: string;
+    enabled: boolean;
+    confidence: number;
+    entityCount: number;
+    subCounts: Record<string, number> | null;
+    /** As stored: `{ sourceEntityType, fields: [{ name, path, type, sampleValues, … }], notes }`. */
+    sourceSchema: Record<string, unknown>;
+    /** As stored: `{ targetEntityType, allowedTargetEntityTypes? }`. */
+    targetSchema: Record<string, unknown>;
+    fieldMappings: PipelineDraftFieldMapping[];
+}
+/** What an importable entity type needs imported first, from the import writers themselves. */
+export interface ImportDependency {
+    entityType: string;
+    dependsOn: string[];
+    /** It also depends on every type in the run starting with one of these (`cms_`). */
+    dependsOnPrefixes: string[];
+}
+/** An enabled entity type whose dependencies were discovered but switched off. */
+export interface ImportDependencyWarning {
+    entityType: string;
+    missing: string[];
+}
+/** A draft and everything the set-up screen shows, read now. */
+export interface PipelineDraft extends PipelineDraftSummary {
+    sourceUrl: string;
+    requestDelayMs: number;
+    /** As typed: a comma-separated list, parsed when the connection is created. */
+    legacyAssetHosts: string;
+    syncPolicy: PipelineSyncPolicy;
+    scheduleType: PipelineScheduleType;
+    cronExpression: string;
+    /** The schedule's zone; a new draft starts with the store's. */
+    timezone: string;
+    /**
+     * Whether the source's prices include tax. Until the merchant sets it (`sourcePricesIncludeTaxChosen`)
+     * it follows what the source reports when a connection is made, and before that the store's own
+     * setting.
+     */
+    sourcePricesIncludeTax: boolean;
+    sourcePricesIncludeTaxChosen: boolean;
+    stockLocationId: string | null;
+    triggerType: PipelineTriggerType;
+    exportEntityTypes: string[];
+    triggerFilter: Record<string, string>;
+    connection: PipelineDraftConnection | null;
+    discovery: PipelineDraftDiscovery | null;
+    schemaMaps: PipelineDraftSchemaMap[];
+    dependencies: ImportDependency[];
+    dependencyWarnings: ImportDependencyWarning[];
+    /** The name the configure step would give it now, in the store's zone. */
+    suggestedName: string | null;
+    /** The store's business time zone; null when it could not be read just now. */
+    storeTimeZone: string | null;
+}
+/** A field change. `version` is the draft's current one. */
+export interface UpdatePipelineDraftInput {
+    version: number;
+    direction?: PipelineDirection;
+    step?: PipelineDraftStep;
+    /** Starts the connection over, even for the same connector. */
+    connectorType?: string;
+    sourceUrl?: string;
+    requestDelayMs?: 50 | 100 | 200 | 300 | 500;
+    legacyAssetHosts?: string;
+    name?: string;
+    syncPolicy?: PipelineSyncPolicy;
+    scheduleType?: PipelineScheduleType;
+    /** A 5-part cron, or '' to clear it. */
+    cronExpression?: string;
+    timezone?: string;
+    sourcePricesIncludeTax?: boolean;
+    /** `null` clears it. */
+    stockLocationId?: string | null;
+    triggerType?: PipelineTriggerType;
+    exportEntityTypes?: string[];
+    triggerFilter?: Record<string, string>;
+}
+export interface UpdatePipelineDraftSchemaMapInput {
+    version: number;
+    enabled?: boolean;
+    fieldMappings?: PipelineDraftFieldMapping[];
+    /** Move a taxonomy to another target its schema map allows. */
+    targetEntityType?: string;
+}
+/** `commit`'s answer: the pipeline, and its first run when one was asked for. */
+export interface CommittedPipelineDraft {
+    pipeline: {
+        id: string;
+        name: string;
+        direction: PipelineDirection;
+        connectionId: string;
+        discoveryId: string | null;
+        scheduleType: PipelineScheduleType;
+        isActive: boolean;
+    };
+    run: {
+        id: string;
+        status: string;
+    } | null;
+    /** The pipeline was saved but its first run did not start; start it from the pipeline. */
+    runError: {
+        code: string;
+        message: string;
+    } | null;
+}
+/** A field of a connector's credentials form, as the connector declares it. */
+export interface PipelineConnectorCredentialField {
+    /** The key to send in `credentials`, in the connector's own spelling (`consumerKey`, `sftpHost`). */
+    key: string;
+    label: string;
+    /**
+     * `password` marks a secret: it is never read back (`publicCredentials` leaves it out), and on
+     * `connections.update` a blank one keeps the stored secret.
+     */
+    type: 'text' | 'password' | 'url';
+    placeholder: string;
+    required: boolean;
+    helpText?: string;
+    /** A heading the form groups the field under (`sftp`, `paths`, `edi`, `warehouse`, `sender`). */
+    group?: string;
+}
+/** One credential field that names where the connector sends its secrets. */
+export interface PipelineCredentialBindingField {
+    key: string;
+    role: 'host' | 'port' | 'user';
+    /** The port a blank `port` field means. */
+    defaultPort?: number;
+}
+/**
+ * What a connection's stored secrets are bound to: its source URL (scheme, host, port and path),
+ * or the named credential fields (an SFTP login). A `connections.update` that moves it must carry
+ * every required secret afresh, or it is refused `PIPELINE_HOST_CHANGE_REQUIRES_CREDENTIALS`.
+ */
+export type PipelineCredentialBinding = {
+    kind: 'source-url';
+} | {
+    kind: 'credential-fields';
+    fields: PipelineCredentialBindingField[];
+};
+/** A connector this deployment offers (`integrations.pipelines.connectors()`). */
+export interface PipelineConnector {
+    /** `woocommerce`, `blujay_wms`, … : a connection's `connectorType`. */
+    type: string;
+    name: string;
+    description: string;
+    logoUrl: string;
+    /** A `coming_soon` connector is listed but cannot be connected yet. */
+    status: 'active' | 'coming_soon';
+    credentialFields: PipelineConnectorCredentialField[];
+    /** Absent from a plugins service deployed before it existed; the server still refuses a move. */
+    credentialBinding?: PipelineCredentialBinding;
+    /** What an import over it can read; empty when it imports nothing. */
+    supportedEntityTypes: string[];
+    /** What an export over it can write; absent when it exports nothing. */
+    supportedExportEntityTypes?: string[];
+    /** It brings its own schema maps, so an import needs no discovery. */
+    fixedSchema?: boolean;
+}
+/** A credential the source checks apart from the main login (WooCommerce's companion plugin). */
+export interface PipelineAuthCheck {
+    id: string;
+    label: string;
+    ok: boolean;
+    /** Why it failed; absent when `ok`. */
+    message?: string;
+}
+/** What a probe of the source reported (`test`, `retest`, and a connection's `siteAnalysis`). */
+export interface PipelineSiteAnalysis {
+    platform: string;
+    version: string;
+    /**
+     * Records per entity type, keyed by the source's own names (a WordPress post type such as
+     * `product_brand` too): kept verbatim, never camelCased.
+     */
+    entityCounts: Record<string, number>;
+    languages: string[];
+    plugins: string[];
+    currency: string;
+    capabilities: string[];
+    authChecks?: PipelineAuthCheck[];
+    /** Whether the source's prices include tax; absent when the connector could not tell. */
+    sourcePricesIncludeTax?: boolean;
+}
+/** A pipeline that runs over a connection. Only the store's own are listed. */
+export interface PipelineConnectionUsage {
+    id: string;
+    name: string;
+    direction: PipelineDirection;
+    isActive: boolean;
+}
+export type PipelineConnectionStatus = 'pending' | 'connected' | 'error';
+/** The throttles a connection may wait between two requests to its source, in milliseconds. */
+export type PipelineRequestDelayMs = 50 | 100 | 200 | 300 | 500;
+/**
+ * A source connection of the store. Never a secret: `publicCredentials` holds the fields its
+ * connector does not mark `password`, and is absent when they cannot be read.
+ */
+export interface PipelineConnection {
+    id: string;
+    connectorType: string;
+    name: string;
+    sourceUrl: string;
+    /** As of the last probe: a failed re-test sets `error`. */
+    status: PipelineConnectionStatus;
+    /** `null`: no throttle. */
+    requestDelayMs: number | null;
+    /** Old hostnames whose image URLs an import rewrites to `sourceUrl`'s host. */
+    legacyAssetHosts: string[] | null;
+    /** What the last successful probe reported; stored data, kept verbatim. */
+    siteAnalysis: PipelineSiteAnalysis | null;
+    lastTestedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    publicCredentials?: Record<string, string>;
+    /** The pipelines that run over it; one in the list blocks `connections.delete`. */
+    pipelineUsage: PipelineConnectionUsage[];
+}
+export interface CreatePipelineConnectionInput {
+    /** A connector's `type` (`connectors()`). */
+    connectorType: string;
+    name: string;
+    /** The source's address: `https://…` for a shop, `sftp://host:port` for an SFTP connector. */
+    sourceUrl: string;
+    /** The connector's `credentialFields`, by `key`. Stored encrypted; never read back. */
+    credentials: Record<string, string>;
+    requestDelayMs?: PipelineRequestDelayMs;
+    legacyAssetHosts?: string[];
+}
+/** Every field optional: one left out stays as stored. */
+export interface UpdatePipelineConnectionInput {
+    name?: string;
+    sourceUrl?: string;
+    /**
+     * MERGED over the stored set: a `password` field sent blank (or left out) keeps the stored
+     * secret while the connection keeps its recipient (`PipelineCredentialBinding`); a non-secret
+     * field sent blank is cleared.
+     */
+    credentials?: Record<string, string>;
+    /** `null` removes the throttle. */
+    requestDelayMs?: PipelineRequestDelayMs | null;
+    legacyAssetHosts?: string[];
+}
+export interface TestPipelineConnectionInput {
+    connectorType: string;
+    sourceUrl: string;
+    credentials: Record<string, string>;
+}
+export interface DetectPipelineConnectionConfigInput {
+    connectorType: string;
+    credentials: Record<string, string>;
+}

package/dist/integrations/types.js

@@ -0,0 +1,8 @@
+/**
+ * The shapes of `admin.integrations.pipelines` (headless spec §7 `pipelines.drafts`).
+ *
+ * Kept verbatim (stored data, never renamed): `triggerFilter`'s keys (reader field names such as
+ * `toState`), `siteAnalysis` and `publicCredentials` (the connector's own keys), and a schema
+ * map's `sourceSchema`, `targetSchema` and `subCounts`.
+ */
+export {};

package/dist/jobs/bulk-action-run.d.ts

@@ -2,7 +2,7 @@ import { type Transport } from '@sixtyninecommerce/core';
 import type { Call } from '../types.js';
 import { type JobHandle } from './index.js';
 /**
- * A bulk action run (`catalog.products.bulk`, and the orders kind of a later release): one call
+ * A bulk action run (`catalog.products.bulk`, `orders.bulk`): one call
  * that acts on many records of the store as a job, each record through its single door and
  * reported on its own. Read back through the Admin API's `bulkActionRun`.
  */
@@ -62,4 +62,13 @@ export declare function readBulkActionRun<Action extends string>(transport: Tran
  * when waiting itself cannot go on: `JOB_WAIT_TIMEOUT`, an aborted signal, or a read refused for
  * a reason polling cannot fix.
  */
-export declare function bulkActionHandle<Action extends string>(transport: Transport, runId: string, options?: Call): JobHandle<BulkActionRun<Action>>;
+export declare function bulkActionHandle<Action extends string, Run extends RunProgress = BulkActionRun<Action>>(transport: Transport, runId: string, options?: Call, 
+/** How one read is made, when the kind selects more than the shared fields (orders). */
+read?: (runId: string, call: Call) => Promise<Run>): JobHandle<Run>;
+/** What waiting on a run reads of it, whatever its kind. */
+interface RunProgress {
+    status: string;
+    done: number;
+    total: number;
+}
+export {};

package/dist/jobs/bulk-action-run.js

@@ -40,15 +40,14 @@ export function readBulkActionRun(transport, runId, options) {
  * when waiting itself cannot go on: `JOB_WAIT_TIMEOUT`, an aborted signal, or a read refused for
  * a reason polling cannot fix.
  */
-export function bulkActionHandle(transport, runId, options) {
+export function bulkActionHandle(transport, runId, options, 
+/** How one read is made, when the kind selects more than the shared fields (orders). */
+read = (id, call) => readBulkActionRun(transport, id, call)) {
     return {
         runId,
         wait(waitOptions) {
             return pollUntilTerminal({
-                read: (signal) => readBulkActionRun(transport, runId, {
-                    ...options,
-                    ...(signal ? { signal } : {}),
-                }),
+                read: (signal) => read(runId, { ...options, ...(signal ? { signal } : {}) }),
                 isTerminal: (run) => TERMINAL_BULK_ACTION_STATUSES.includes(run.status),
                 onTimeout: (seen) => bulkWaitTimeout(runId, seen),
                 ...waitOptions,