@sequenceholdings/pipeline-spec 0.1.0

package/dist/bodies/ingestion.d.ts

@@ -0,0 +1,359 @@
+import { z } from 'zod';
+import { isoDurationSchema, repoRelativePathSchema, symbolicRefSchema } from '../primitives.js';
+/**
+ * Ingestion stages declare **feeds into a volume landing zone** — never bronze
+ * tables, which are platform-derived. This body encodes the append-only-bronze
+ * architecture: volumes-first landing, snapshot_mode batch semantics, symbolic
+ * worker/credential bindings, and the decode/write split.
+ *
+ * ## What the platform derives from a feed (not authored)
+ *
+ * Ingestion lands in **catalog-per-source** catalogs (estate precedent:
+ * `src_banksouth_jack_henry`, `src_mock_data`): bronze lives in
+ * `src_<source>`, an ACCOUNT-LEVEL asset shared across deployments with a
+ * single writing deployment. The deployment catalog (`TargetFacts.catalog`)
+ * owns silver/gold/report/serving ONLY and never appears in an ingestion name.
+ *
+ * - **Source catalog** — `src_<source>` (canonical derivation:
+ *   `sourceCatalog`; the source identity is underscore-constrained, so the
+ *   catalog name is deterministic and UC-legal).
+ * - **Volume layout** — `/Volumes/src_<source>/bronze/<feed>/batch_id=<ts>/`
+ *   (UC volumes are `/Volumes/<catalog>/<schema>/<volume>/…`, so the schema
+ *   is `bronze` and the volume is the feed): every batch lands as raw files
+ *   under a batch directory keyed by ingestion timestamp. Canonical
+ *   derivation: `feedVolumePath` (tests pin the documented string to it).
+ * - **Bronze table name** — one append-only bronze table per feed:
+ *   `src_<source>.bronze.<feed>` — the catalog scopes the source, so the
+ *   table name needs no `<source>_` prefix (canonical derivation:
+ *   `feedBronzeTable`).
+ * - **Envelope columns** — the materializer stamps `batch_id`, `ingested_at`,
+ *   `source_system`, and `content_hash` onto every row. These names are
+ *   RESERVED (`RESERVED_ENVELOPE_COLUMNS` in `../constants.js`) — a feed's
+ *   `natural_key`/`cursor.column` may not name one (`refineFeed` below);
+ *   the materializer itself rejects a source column collision at runtime,
+ *   since a feed's full column set is only known at decode time.
+ * - **Presence manifest** — for `full_snapshot` feeds the platform records
+ *   which natural keys appeared in each batch, so downstream deletion
+ *   detection never needs source-side tombstones.
+ *
+ * ## The decode/write split
+ *
+ * Decoders are developer-provided **pure functions (file contents → rows)**
+ * invoked by the platform materializer for non-standard formats. Decoders
+ * never hold table-write credentials — the platform materializer performs
+ * envelope stamping and the append. **Bronze materialization does no semantic
+ * work**: no type coercion, dedup, normalization, or filtering — that is
+ * cleaning-transformation territory.
+ */
+export { isoDurationSchema, repoRelativePathSchema, symbolicRefSchema };
+export declare const SNAPSHOT_MODES: readonly ["full_snapshot", "incremental", "event_stream"];
+export declare const snapshotModeSchema: z.ZodEnum<{
+    full_snapshot: "full_snapshot";
+    incremental: "incremental";
+    event_stream: "event_stream";
+}>;
+export type SnapshotMode = z.infer<typeof snapshotModeSchema>;
+/**
+ * Feed formats. `xlsx` is RESERVED: present in the enum but rejected at
+ * validation until the platform ships its default spreadsheet decoder (sheet
+ * selection / header detection stay byte-shape decoding — type coercion stays
+ * in cleaning). `custom` requires a `decoder`.
+ */
+export declare const FEED_FORMATS: readonly ["parquet", "json", "csv", "xlsx", "custom"];
+export declare const feedFormatSchema: z.ZodEnum<{
+    json: "json";
+    custom: "custom";
+    parquet: "parquet";
+    csv: "csv";
+    xlsx: "xlsx";
+}>;
+export type FeedFormat = z.infer<typeof feedFormatSchema>;
+/**
+ * Incremental cursor declaration. `encoding` is an extensible string (e.g.
+ * `yyyyddd` for Jack-Henry-style Julian dates) — the SDK stays
+ * provider-neutral and never enumerates vendor encodings.
+ */
+export declare const cursorSchema: z.ZodObject<{
+    column: z.ZodString;
+    encoding: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const feedSchema: z.ZodObject<{
+    columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+    }, z.core.$strict>>>;
+    documentation_ref: z.ZodOptional<z.ZodString>;
+    snapshot_mode: z.ZodEnum<{
+        full_snapshot: "full_snapshot";
+        incremental: "incremental";
+        event_stream: "event_stream";
+    }>;
+    natural_key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    cursor: z.ZodOptional<z.ZodObject<{
+        column: z.ZodString;
+        encoding: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pii: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        contains_pii: "contains_pii";
+    }>>;
+    format: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        custom: "custom";
+        parquet: "parquet";
+        csv: "csv";
+        xlsx: "xlsx";
+    }>>;
+    decoder: z.ZodOptional<z.ZodString>;
+    extraction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    freshness_slo: z.ZodOptional<z.ZodString>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    column_descriptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>;
+export type FeedSpec = z.infer<typeof feedSchema>;
+/** Feed documentation changes do not change downstream compatibility. */
+export declare function feedContract(feed: FeedSpec): Omit<FeedSpec, 'description' | 'columns' | 'column_descriptions' | 'documentation_ref'>;
+/**
+ * Ingestion schedule: cron + tz + the shared operation policy vocabulary.
+ * Optional by design — the future `upload` runtime is event-driven (file
+ * arrival), so a schedule is meaningless there.
+ */
+export declare const scheduleSchema: z.ZodObject<{
+    cron: z.ZodString;
+    tz: z.ZodString;
+    policy: z.ZodOptional<z.ZodObject<{
+        singleton: z.ZodOptional<z.ZodBoolean>;
+        exclusion_group: z.ZodOptional<z.ZodString>;
+        timeout_minutes: z.ZodOptional<z.ZodNumber>;
+        mutates: z.ZodOptional<z.ZodBoolean>;
+        cooldown_minutes: z.ZodOptional<z.ZodNumber>;
+        requires_approval: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ScheduleSpec = z.infer<typeof scheduleSchema>;
+/**
+ * Where the ingestion code runs:
+ * - `databricks` — a platform-scheduled job in the deployment workspace,
+ *   pulling from an external system's API (`source` required).
+ * - `edge-worker` — an on-prem/VM worker registered in the platform registry
+ *   (`worker` required): the SEQUENCE2-style extraction posture.
+ * - `upload` — RESERVED, rejected at validation ('not yet supported').
+ *   Future semantics: no entrypoint/schedule/credential; the platform upload
+ *   surface writes the feed's batch directories; the materializer fires on
+ *   file arrival (Databricks file-arrival trigger); the batch ledger records
+ *   the uploading initiator. Covers the spreadsheet→volume→cleaning→ontology
+ *   expansion (seeds CSVs, iSeries dumps, BSM mock data).
+ */
+export declare const INGESTION_RUNTIMES: readonly ["databricks", "edge-worker", "upload"];
+export declare const ingestionRuntimeSchema: z.ZodEnum<{
+    databricks: "databricks";
+    "edge-worker": "edge-worker";
+    upload: "upload";
+}>;
+export type IngestionRuntime = z.infer<typeof ingestionRuntimeSchema>;
+/** Hard ceiling that keeps a malformed authoring file from stampeding a VM. */
+export declare const MAX_WORKER_CONCURRENT = 32;
+export declare const DEFAULT_MATERIALIZER_CONCURRENT = 32;
+export declare const MAX_MATERIALIZER_CONCURRENT = 64;
+export declare const MATERIALIZER_STRATEGIES: readonly ["per_feed", "sharded"];
+export declare const materializerStrategySchema: z.ZodEnum<{
+    per_feed: "per_feed";
+    sharded: "sharded";
+}>;
+export type MaterializerStrategy = z.infer<typeof materializerStrategySchema>;
+export declare const materializerConcurrencySchema: z.ZodObject<{
+    max_concurrent: z.ZodNumber;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        per_feed: "per_feed";
+        sharded: "sharded";
+    }>>;
+}, z.core.$strict>;
+/**
+ * Symbolic worker binding — machine and Data Sync family identifiers, never
+ * connection strings or managed-secret bindings.
+ *
+ * Which fields feed physical-name derivation: `data_source` is the source
+ * identity (bronze table names + volume paths derive from it, hence the
+ * identifier grammar); `machine` is a registry machine id (SEQUENCE2-style),
+ * `credential` a Data Sync environment family, and `operation` a machine-local
+ * Data Sync operation id — none appears in any derived name.
+ */
+export declare const workerSchema: z.ZodObject<{
+    machine: z.ZodString;
+    data_source: z.ZodString;
+    credential: z.ZodString;
+    operation: z.ZodOptional<z.ZodString>;
+    max_concurrent: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * Symbolic source binding for databricks-runtime API pulls. `system` is the
+ * source identity (feeds derived UC names — identifier grammar).
+ *
+ * `credential` names a binding family when the upstream API is authenticated.
+ * Omit it for genuinely keyless / public sources (e.g. ESPN's public site API)
+ * — never invent a sentinel binding. Resolution and compiled `credential_*`
+ * parameters only occur when this field is present.
+ */
+export declare const sourceSystemSchema: z.ZodObject<{
+    system: z.ZodString;
+    credential: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Feed names are snake_case identifiers (they become volume path segments and bronze table parts). */
+export declare const feedNameSchema: z.ZodString;
+export declare const ingestionBodyShape: {
+    runtime: z.ZodEnum<{
+        databricks: "databricks";
+        "edge-worker": "edge-worker";
+        upload: "upload";
+    }>;
+    /** Required iff `runtime: edge-worker`; forbidden otherwise. */
+    worker: z.ZodOptional<z.ZodObject<{
+        machine: z.ZodString;
+        data_source: z.ZodString;
+        credential: z.ZodString;
+        operation: z.ZodOptional<z.ZodString>;
+        max_concurrent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    /** Required iff `runtime: databricks`; forbidden otherwise. */
+    source: z.ZodOptional<z.ZodObject<{
+        system: z.ZodString;
+        credential: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    /** Databricks-side feed materializer concurrency, independent of extraction. */
+    materializer: z.ZodOptional<z.ZodObject<{
+        max_concurrent: z.ZodNumber;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            per_feed: "per_feed";
+            sharded: "sharded";
+        }>>;
+    }, z.core.$strict>>;
+    feeds: z.ZodRecord<z.ZodString, z.ZodObject<{
+        columns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+        }, z.core.$strict>>>;
+        documentation_ref: z.ZodOptional<z.ZodString>;
+        snapshot_mode: z.ZodEnum<{
+            full_snapshot: "full_snapshot";
+            incremental: "incremental";
+            event_stream: "event_stream";
+        }>;
+        natural_key: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        cursor: z.ZodOptional<z.ZodObject<{
+            column: z.ZodString;
+            encoding: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        pii: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            contains_pii: "contains_pii";
+        }>>;
+        format: z.ZodOptional<z.ZodEnum<{
+            json: "json";
+            custom: "custom";
+            parquet: "parquet";
+            csv: "csv";
+            xlsx: "xlsx";
+        }>>;
+        decoder: z.ZodOptional<z.ZodString>;
+        extraction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        freshness_slo: z.ZodOptional<z.ZodString>;
+        optional: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        column_descriptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    schedule: z.ZodOptional<z.ZodObject<{
+        cron: z.ZodString;
+        tz: z.ZodString;
+        policy: z.ZodOptional<z.ZodObject<{
+            singleton: z.ZodOptional<z.ZodBoolean>;
+            exclusion_group: z.ZodOptional<z.ZodString>;
+            timeout_minutes: z.ZodOptional<z.ZodNumber>;
+            mutates: z.ZodOptional<z.ZodBoolean>;
+            cooldown_minutes: z.ZodOptional<z.ZodNumber>;
+            requires_approval: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    /** Spec-wide max staleness; feeds may override per-feed. */
+    freshness_slo: z.ZodOptional<z.ZodString>;
+    /** Raw-file retention window — an explicit replay buffer, not an archive. */
+    retention: z.ZodOptional<z.ZodString>;
+    /** Repo-relative code path. Required for databricks / edge-worker runtimes. */
+    entrypoint: z.ZodOptional<z.ZodString>;
+};
+/**
+ * The source identity a stage ingests from — `source.system` for databricks
+ * runtimes, `worker.data_source` for edge workers (stage id as the final
+ * fallback for future runtimes). This identity determines EVERY derived
+ * bronze name, so it is part of the contract surface (`contract_hash`) and
+ * the single input to the derivation helpers below.
+ */
+export declare function ingestionSourceIdentity(spec: {
+    readonly source?: {
+        readonly system: string;
+    };
+    readonly worker?: {
+        readonly data_source: string;
+    };
+    readonly stage: string;
+}): string;
+/**
+ * Canonical per-source catalog: `src_<source>`. Ingestion never lands in the
+ * deployment catalog — per-source catalogs are account-level assets shared
+ * across deployments (one writing deployment), per the locked topology.
+ *
+ * Because the catalog is ACCOUNT-level, the source identity is an
+ * account-global namespace: where a source system spans tenants, the author
+ * scopes the tenant INTO the identity (`banksouth_candescent`, matching the
+ * estate's `src_banksouth_jack_henry`); first-party/global sources need no
+ * scope (`src_mock_data`). The registry milestone enforces single-writer per
+ * `src_*` FQN account-wide and may introduce registry-owned catalog bindings
+ * that supersede this deterministic default.
+ */
+export declare function sourceCatalog(source: string): string;
+/**
+ * Canonical volume layout for a feed's batches:
+ * `/Volumes/src_<source>/bronze/<feed>` — batches land under
+ * `batch_id=<ts>/` inside it. The ONE derivation the resolver, docs, and
+ * tests share. Derived from the spec's own source identity — never from
+ * `TargetFacts.catalog`.
+ */
+export declare function feedVolumePath(args: {
+    source: string;
+    feed: string;
+}): string;
+/** Canonical bronze table FQN for a feed: `src_<source>.bronze.<feed>`. */
+export declare function feedBronzeTable(args: {
+    source: string;
+    feed: string;
+}): string;
+/**
+ * Canonical capacity/exclusion group for every stage extracting from ONE
+ * machine + data source: `<machine>_<data_source>`.
+ *
+ * This is the anti-stampede identity. With one stage per table, ~150 sibling
+ * stages point at a single VM holding a single ODBC connection to the core; a
+ * per-stage exclusion group would declare them all mutually independent and let
+ * every one of them fire at once. Grouping by the contended upstream instead
+ * means the declared policy matches physical reality, and `worker.max_concurrent`
+ * is the budget within the group.
+ *
+ * Machine ids permit hyphens (symbolic-ref grammar) while group names are
+ * identifiers, so hyphens are normalized to underscores.
+ */
+export declare function workerCapacityGroup(worker: {
+    readonly machine: string;
+    readonly data_source: string;
+}): string;
+/** Structural slice of a stage spec the ingestion refinement needs. */
+export interface IngestionBody {
+    readonly runtime: IngestionRuntime;
+    readonly worker?: z.infer<typeof workerSchema>;
+    readonly source?: z.infer<typeof sourceSystemSchema>;
+    readonly feeds: Record<string, FeedSpec>;
+    readonly entrypoint?: string;
+    readonly slos?: {
+        readonly freshness?: string;
+    };
+}
+/** Cross-field validation for `type: ingestion` bodies (invoked from the envelope refinement). */
+export declare function refineIngestionBody(body: IngestionBody, ctx: z.RefinementCtx): void;
+//# sourceMappingURL=ingestion.d.ts.map

package/dist/bodies/ingestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingestion.d.ts","sourceRoot":"","sources":["../../src/bodies/ingestion.ts"],"names":[],"mappings":"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"}