@ingestron/core 0.12.3 → 0.12.5

package/README.md

@@ -44,6 +44,11 @@ selects the output columns. Connector packages define the allowed table source
 shape, so the same project layout works across source types. Older stream-based
 connector releases remain supported.
 
+The `contract_scaffold` operation creates a minimal draft ODCS contract from a
+user-supplied first field. `connection_flow_add` accepts an optional provider
+execution mapping; when omitted it authors local execution. Providers and the
+compiler still validate the selected execution mode during project checks.
+
 ## Integration guides
 
 - [Operation and editor API](docs/api.md): requests, results, permissions, errors

package/dist/compiler-fingerprint.json

@@ -3,11 +3,11 @@
     "dist/assets/schemas/ODCS-LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
     "dist/assets/schemas/odcs-3.1.0.json": "1a35de14c688b400fef306564f66e2af3304f057cd5cd6e7b847c1a8bf252c5b",
     "dist/assets/schemas/provenance.json": "4b5eb1fd89b81223f7946113b651d5a3a18adaa28948e43c3615dd851fb6844e",
-    "dist/core/authoring.js": "405c818184960c93a0cd0c041af2d415d56f62670ff91b0fb5f0d2aeed1feb9b",
+    "dist/core/authoring.js": "84d848f46e612c241b615d3bd6868563696ca1f6504b27b76440da9bb94036fc",
     "dist/core/config.js": "b7e7138f7cc4a7b4ec8f6d0f0616c8802f2d802ec29aa09b40c1fc5c9324e016",
-    "dist/core/connections.js": "37b797b402788e00c51f3cac93b87342d158ed9b279753db91006d2d6c66bb4a",
+    "dist/core/connections.js": "48a06440a2d82eee36ef8a22a9343b52194e567263a5062f06fddd5def2c3c3e",
     "dist/core/connector-package.js": "de9729e9e4b0cf05bd1ef347e57ffd489245bb68efce5c313ccba72b78409f41",
-    "dist/core/contracts.js": "a1b7fd28f776117cca86a25c6c70e852ff57ffea2bb9e7accbf2d583948d9dde",
+    "dist/core/contracts.js": "a4af0b29ef8277a19d6e0c1d5de3059e09cdd3d45baefe9841cab1fb60985ecc",
     "dist/core/deliveries.js": "a4d2cb1213bc4c02cffb962dcb943ba98e261d37cfb21041948ec637599db080",
     "dist/core/delivery-exports.js": "d895b044c08f2059f0275724205120c72dd4bf5b74170bb01bdf42dd9d526d56",
     "dist/core/development.js": "2b55b15d545172e527cf66868d96d97c5ca081d0a83892ffd253eadaa3cc1b39",
@@ -21,9 +21,9 @@
     "dist/core/installed-plugins.js": "817ed411aef6f5b966a1828893081406805d2c8764d2ca20fd7e250e8a2168a8",
     "dist/core/model-pack-schema.js": "e3eb7ff33ddc652643e3f896637de0034004cd0cf26b0e296a074f830ae0b870",
     "dist/core/model-packs.js": "fee776ea0804dc66c9f140e57d94a3922d69c52d03c72079842ec43417616b0d",
-    "dist/core/operations.js": "7f4a9eeee19d3e1e4c1beecc0350e38d386f012edfb31c3248efcd22ebd40a77",
+    "dist/core/operations.js": "c3d295df7450c6f0f730bf3ab05c223361fb4015f2e4cbffac7c09a16ef0f903",
     "dist/core/package-references.js": "bd3085eb6dcdac399d79af109d0a9e710a0532eba61e5298dc842aec9c7ef10a",
-    "dist/core/packages.js": "6af57d7f2b3d78837a39cf9b14a5d8151a6825dfce359680382fd8096a08d259",
+    "dist/core/packages.js": "c6bcbc90aa3597fcd4205b27136221229d9efedc9bfa68a83a134cb5e8f51d2b",
     "dist/core/planner.js": "974c6bac5c533a32a7c45f797ef4d857c644448aa243a929caca5917fb9f3fb8",
     "dist/core/project-build.js": "18ffe962068967af255e77f1dc48fa4dd9161cd50659a8a3d9ac3b161856082e",
     "dist/core/project-packages.js": "b031dd9e3c5c147e8e1ed589b5eab21b9067acbefc1d4cd1dc5b6b7018cc39cf",
@@ -31,7 +31,7 @@
     "dist/core/provider-starter.js": "69795c1b79360e48664e91db0768f813fe4efc91aede003e1bf032f71731754c",
     "dist/core/report-pack-schema.js": "fe8ecdc2b8deacd8b2a1e46588ee06744a7b6d8e7342786e320f74cc848665fa",
     "dist/core/schema.js": "821e79cfc56dbd8c206959c53c0cda6d81507ae78010da1ec614e204c17d96eb",
-    "dist/core/workflows.js": "e0b9e34fdd9b3f56403e8beb58e2b0bfbc0604beccb3113fc529c460817bc4d4",
+    "dist/core/workflows.js": "6573e1a2fd5873947bcba2809b5a4fb93e05db9a97ee5e0c294d67dae5947ff1",
     "dist/plugins/authoring.js": "ff985a7173c7aeda4a431a8603a4ab8631dc5134486578ede7d1301ebc3e6a19",
     "dist/plugins/compatibility.js": "a6591cfa4ca5a324fd29856e51319e39be470d6ed835ee268b293727ce11f8b7",
     "dist/plugins/generation.js": "7b0bae4de23edab4c2596d1f8ed2244d70b30fcae60395994b3964ffc845e9d5",
@@ -43,11 +43,11 @@
     "dist/version.js": "48af2aa1e425f1e387c082bbf0ad2c0c8d757c468101a614c3864153a94e6889"
   },
   "sources": {
-    "src/core/authoring.ts": "e1f02cf6c50cda20a62c1ea318908854939ab5be7da7de829350c7e11788be01",
+    "src/core/authoring.ts": "e01136d3b54410ea0f44302bb43eefe2c2431138bee47600f0c97680785b8cab",
     "src/core/config.ts": "f282eb246438608e1951556dfeab9372daf65330a15a9d159d36d1f940370344",
-    "src/core/connections.ts": "dbdaca4193efa203cffa02fd819b95f82bbd604a7678ba7dc6ba065205c49ce7",
+    "src/core/connections.ts": "608dd839421b08b612fb1e6f861bd934e2443dce72543b002f23b38b7dafc5b7",
     "src/core/connector-package.ts": "a36151f6ffb49836547984eae871023ad1ad69a136f33cd6ad608496f84c85f8",
-    "src/core/contracts.ts": "b7445086085b17d5ae8d5a7f4e2e849f286948e1a2a146ceb79660846e8616e5",
+    "src/core/contracts.ts": "f10e2d689709665d7aea27d0c8861ae6d8b7039676d361389bc59a8f00e86aa9",
     "src/core/deliveries.ts": "6be0a7059c057420ba22a5515703164a892fac9e79a5bdb0e0871ea0b92ddd15",
     "src/core/delivery-exports.ts": "45a4d13e73a3809340fcd0f018dd06e2e360c67c1a117c672cd48be463c82d58",
     "src/core/development.ts": "decd47d8f6ca3289fea45331f27b99b0feb7188ae0a9e152c6459cc00658e7bd",
@@ -61,9 +61,9 @@
     "src/core/installed-plugins.ts": "951d15cdd8ca4a2c7d97fb01a46838822fe1b2fcf083ff8cf4bdca20d0997a2d",
     "src/core/model-pack-schema.ts": "bc9b30ab257fd25766cba63aa2fb6891c05e4b3eccf56d820caaab2dcc4147b4",
     "src/core/model-packs.ts": "a110d319f6feeff22a2d0d3a99ce5e49e56817d0cc27ab77d831d04a945ddfd3",
-    "src/core/operations.ts": "e0a5a0e869e96de4e869f89e0fd794cb9fa537a16fb1f37fd8cf2b7ca777c08d",
+    "src/core/operations.ts": "bdb6b3dfaa5acd8367853dbe2d08013f5d68f6443afaacbaec8973f3d96424f0",
     "src/core/package-references.ts": "5c5cee7e140158928e2e5a37f426520c7c2f042546a37eed4507d79326181f5a",
-    "src/core/packages.ts": "5a8ac2c2c2b5ac70c97339d7d5b9d76ac44422566c1dcbb780323de512905fd4",
+    "src/core/packages.ts": "8a9b6612325de68ab2610f540bd39e4f899b06d1cc1fbd54ecfd2abb8b4e9c40",
     "src/core/planner.ts": "2c6f0d53e21cbb60fc2433e7da1245707133336274c60b9a5678614dabf09bca",
     "src/core/project-build.ts": "7fa5038e7e2ff2625a30ffae282369954a5989347c6435849b72c95f2e52e247",
     "src/core/project-packages.ts": "4c5cb98aeb5030db7cf2c851cd9e40ed9aae038517fba2d8d7159e884f08b7a0",
@@ -71,7 +71,7 @@
     "src/core/provider-starter.ts": "eeb504e347638bb933d204dd4d5a7e3e94ff45db136c5edd3fb457061342e405",
     "src/core/report-pack-schema.ts": "cf2c68f3725cef847627ce61acd0887f04d0067bc324841d8a552bcb12d274b0",
     "src/core/schema.ts": "a99a90e51be10ed56713573df6f238e6aca5b897a9679fe7bd2a8c0ad1e7f586",
-    "src/core/workflows.ts": "f9e8d7f0a3841b5e385a5279e202f5a3334972bb549c8c85f01e7cfbb4e16f25",
+    "src/core/workflows.ts": "52f755e429a80e3283be030af58469158fdd19a357981b653e879d97194ec59a",
     "src/plugins/authoring.ts": "a0d68d406b4569c0b48eec458407d24c3d4eeed5b7918c6c4fcb3828ada93fe5",
     "src/plugins/compatibility.ts": "b5d357a1dc2a972cf8209311602f9fd816ba0a59cbe747f86f1b5567754073ea",
     "src/plugins/generation.ts": "a495906af09cf7bf820c7aba390bf742d7e94328ce708a2ff40f613f451fe237",

package/dist/core/authoring.d.ts

@@ -34,6 +34,46 @@ export declare function addFlow(root: string, options: {
     inputDataset?: string;
     provider?: string;
 }): Proposal;
+/** Author a connector instance without requiring the editor to edit project YAML. */
+export declare function addConnection(root: string, options: {
+    id: string;
+    package: string;
+    sourceId: string;
+    tenantId: string;
+    binding?: string;
+    settings: Record<string, unknown>;
+}): Proposal;
+/** Create a minimal reviewed-by-human starting point without reading source data. */
+export declare function scaffoldContract(root: string, options: {
+    id: string;
+    table: string;
+    field: string;
+    type: "string" | "integer" | "number" | "boolean";
+}): Proposal;
+/** Add a connection-backed ingestion flow with one selected ODCS table. */
+export declare function addConnectionFlow(root: string, options: {
+    id: string;
+    provider: string;
+    connection: string;
+    table: string;
+    contract: string;
+    source: Record<string, unknown>;
+    execution?: Record<string, unknown>;
+}): Proposal;
+/** Apply a reviewed source-field selection to one ODCS table. Approval remains separate. */
+export declare function mapContractFields(root: string, options: {
+    apiVersion: "ingestron.field-mapping/v1";
+    flow: string;
+    environment: string;
+    contract: string;
+    discovery: string;
+    stream: string;
+    table: string;
+    fields: {
+        source: string;
+        target: string;
+    }[];
+}): Proposal;
 export declare function addTable(root: string, options: {
     flow: string;
     id: string;

package/dist/core/authoring.js

@@ -5,10 +5,28 @@ import { resolve, dirname, relative } from "node:path";
 import { parseDocument, stringify } from "yaml";
 import { check, digest, canonical, merge, Problem } from "./errors.js";
 import { Configuration } from "./config.js";
-import { projectSchema } from "./schema.js";
+import { packageReferenceSchema, projectSchema } from "./schema.js";
 import { projectPackages } from "./project-packages.js";
 import { contractColumns } from "./contracts.js";
-import { fence, installedProviders, canonicalPackageReference, } from "./packages.js";
+import { fence, installedProviders, canonicalPackageReference, configuredPackageReference, resolvePackage, packageYaml, } from "./packages.js";
+function concisePackageReference(root, value) {
+    const pkg = packageReferenceSchema.parse(value);
+    const reference = configuredPackageReference(pkg);
+    const installed = resolvePackage(root, reference);
+    const manifest = packageYaml(installed.file);
+    const short = `${manifest.id}@${manifest.version}`;
+    try {
+        const selected = resolvePackage(root, short);
+        if (selected.entry.repository === installed.entry.repository &&
+            selected.entry.path === installed.entry.path &&
+            selected.entry.commit === installed.entry.commit)
+            return short;
+    }
+    catch {
+        // Keep an explicit reference if multiple installed packages share the ID.
+    }
+    return `${pkg.source}@${pkg.version}`;
+}
 const yaml = (text, file) => {
     const doc = parseDocument(text, { uniqueKeys: true });
     check(!doc.errors.length, "YAML", doc.errors[0]?.message ?? "Invalid YAML", file);
@@ -116,7 +134,8 @@ export function initialise(root, options) {
             "project.yaml": stringify({
                 apiVersion: "ingestron.project/v1",
                 id: options.id,
-                providers: { packages: {}, configurations: {} },
+                packages: {},
+                providers: { configurations: {} },
                 defaults: {},
                 environments: Object.fromEntries(environments.map((name) => [
                     name,
@@ -150,6 +169,16 @@ export function initialise(root, options) {
         name === ".gitignore" ||
         /^environments\/[\w-]+\.yaml$/.test(name));
     check(files["project.yaml"], "PROVIDER", "Provider must author a project");
+    const authored = yaml(files["project.yaml"], "project.yaml").toJS();
+    const providerPackages = authored.providers?.packages ?? {};
+    authored.packages ??= {};
+    for (const [name, value] of Object.entries(providerPackages)) {
+        check(!Object.hasOwn(authored.packages, name), "PACKAGE", `Duplicate package alias ${name}`);
+        authored.packages[name] = concisePackageReference(root, value);
+    }
+    if (authored.providers)
+        delete authored.providers.packages;
+    files["project.yaml"] = stringify(authored);
     // Providers may return JSON (valid YAML); editable scaffolds use block YAML.
     for (const [name, text] of Object.entries(files)) {
         if (name.endsWith(".yaml"))
@@ -161,12 +190,14 @@ export function initialise(root, options) {
 }
 export function migrateProvider(root, options) {
     const reader = new Configuration(root), doc = yaml(reader.text("project.yaml"), "project.yaml");
-    check(doc.hasIn(["providers", "packages", options.package]), "PACKAGE", "Unknown project package");
+    const location = doc.hasIn(["packages", options.package])
+        ? ["packages", options.package]
+        : ["providers", "packages", options.package];
+    check(doc.hasIn(location), "PACKAGE", "Unknown project package");
     const selected = providerReference(root, options.to);
-    doc.setIn(["providers", "packages", options.package], {
-        source: selected.source,
-        version: selected.version,
-    });
+    doc.setIn(location, location[0] === "packages"
+        ? concisePackageReference(root, `${selected.source}@${selected.version}`)
+        : { source: selected.source, version: selected.version });
     return preview(root, { "project.yaml": doc.toString() });
 }
 function flowFile(root, id) {
@@ -198,7 +229,7 @@ export function addFlow(root, options) {
             value: yaml(reader.text(file), file).toJS(),
         };
     });
-    const files = providerAuthor(root, `${pkg.source}@${pkg.version}`, {
+    const files = providerAuthor(root, resolvePackage(root, configuredPackageReference(pkg)).reference, {
         operation: "flow",
         options,
         configuration,
@@ -213,6 +244,169 @@ export function addFlow(root, options) {
     files["project.yaml"] = project.toString();
     return preview(root, files);
 }
+/** Author a connector instance without requiring the editor to edit project YAML. */
+export function addConnection(root, options) {
+    const reader = new Configuration(root);
+    const project = yaml(reader.text("project.yaml"), "project.yaml");
+    const parsed = projectSchema.parse(reader.load());
+    check(!Object.hasOwn(parsed.connections, options.id), "OWNER", `Connection ${options.id} already exists`);
+    const pkg = projectPackages(parsed)[options.package];
+    check(pkg, "PACKAGE", `Unknown connector package ${options.package}`);
+    const locked = resolvePackage(root, configuredPackageReference(pkg));
+    const manifest = packageYaml(locked.file);
+    check(manifest.apiVersion === "ingestron.connector/v1", "PACKAGE", "Select an installed connector package");
+    project.setIn(["connections", options.id], {
+        package: options.package,
+        sourceId: options.sourceId,
+        tenantId: options.tenantId,
+        ...(options.binding ? { binding: options.binding } : {}),
+        settings: options.settings,
+    });
+    return preview(root, { "project.yaml": project.toString() });
+}
+/** Create a minimal reviewed-by-human starting point without reading source data. */
+export function scaffoldContract(root, options) {
+    const path = `contracts/${options.id}.odcs.yaml`;
+    check(!existsSync(fence(root, path)), "OWNER", `Contract ${path} already exists`);
+    const physicalTypes = {
+        string: "STRING",
+        integer: "BIGINT",
+        number: "DOUBLE",
+        boolean: "BOOLEAN",
+    };
+    const contract = {
+        apiVersion: "v3.1.0",
+        kind: "DataContract",
+        id: options.id,
+        name: options.id.replaceAll("-", " "),
+        version: "0.1.0",
+        status: "draft",
+        description: {
+            purpose: "Review this draft against source metadata before approval.",
+        },
+        schema: [
+            {
+                name: options.table,
+                logicalType: "object",
+                physicalType: "table",
+                properties: [
+                    {
+                        name: options.field,
+                        logicalType: options.type,
+                        physicalType: physicalTypes[options.type],
+                        required: false,
+                    },
+                ],
+            },
+        ],
+    };
+    contractColumns(contract, path);
+    return preview(root, { [path]: stringify(contract) });
+}
+/** Add a connection-backed ingestion flow with one selected ODCS table. */
+export function addConnectionFlow(root, options) {
+    const reader = new Configuration(root);
+    const project = yaml(reader.text("project.yaml"), "project.yaml");
+    const raw = project.toJS();
+    const parsed = projectSchema.parse(reader.load());
+    check(!parsed.flows.some((flow) => flow?.id === options.id), "OWNER", `Flow ${options.id} already exists`);
+    check(parsed.connections[options.connection], "CONNECTION", "Select a configured connection");
+    check(parsed.providers.configurations[options.provider], "PROVIDER", "Select a configured provider");
+    check(!resolve(root, options.contract).startsWith(resolve(root, "flows", options.id) + "/"), "PATH", "Contract must be outside the new flow directory");
+    const contractFile = fence(root, options.contract);
+    check(existsSync(contractFile), "ODCS", "Contract file is missing");
+    contractColumns(reader.load(options.contract), options.contract);
+    const path = `flows/${options.id}/flow.yaml`;
+    check(!existsSync(fence(root, path)), "OWNER", `Flow ${options.id} already exists`);
+    const contractRef = relative(dirname(resolve(root, path)), contractFile).replaceAll("\\", "/");
+    const flow = {
+        apiVersion: "ingestron.flow/v1",
+        kind: "ingestion",
+        id: options.id,
+        provider: options.provider,
+        ingestion: {
+            connection: options.connection,
+            execution: options.execution ?? { mode: "local" },
+        },
+        tables: {
+            [options.table]: {
+                source: options.source,
+                contract: {
+                    $resolve: contractRef.startsWith(".")
+                        ? contractRef
+                        : `./${contractRef}`,
+                },
+            },
+        },
+    };
+    project.set("flows", [...raw.flows, { $resolve: `./${path}` }]);
+    return preview(root, {
+        "project.yaml": project.toString(),
+        [path]: stringify(flow),
+    });
+}
+/** Apply a reviewed source-field selection to one ODCS table. Approval remains separate. */
+export function mapContractFields(root, options) {
+    const reader = new Configuration(root);
+    const discovered = JSON.parse(reader.text(options.discovery));
+    check(discovered.apiVersion === "ingestron.singer-discovery/v1", "DISCOVERY", "Select saved Singer discovery evidence");
+    const stream = discovered.catalog?.streams?.find((entry) => entry?.stream === options.stream ||
+        entry?.tap_stream_id === options.stream);
+    check(stream, "DISCOVERY", "Selected source dataset is absent from discovery");
+    const sourceFields = stream.schema?.properties;
+    check(sourceFields &&
+        typeof sourceFields === "object" &&
+        !Array.isArray(sourceFields), "DISCOVERY", "Discovery has no field schema");
+    const doc = yaml(reader.text(options.contract), options.contract);
+    const contract = doc.toJS();
+    contractColumns(contract, options.contract);
+    check(contract.schema[0].name === options.table, "ODCS", "Selected contract table differs from the workflow table");
+    const previous = new Map(contract.schema[0].properties.map((property) => [
+        property.physicalName ?? property.name,
+        property,
+    ]));
+    const previousTargets = new Map(contract.schema[0].properties.map((property) => [
+        property.name,
+        property,
+    ]));
+    const sources = new Set(), targets = new Set();
+    const properties = options.fields.map(({ source, target }) => {
+        check(Object.hasOwn(sourceFields, source) && !sources.has(source), "MAPPING", `Unknown or duplicate source field ${source}`);
+        check(!targets.has(target), "MAPPING", `Duplicate target field ${target}`);
+        sources.add(source);
+        targets.add(target);
+        const old = (previous.get(source) ?? previousTargets.get(target));
+        if (old) {
+            const next = { ...old, name: target };
+            if (source !== target)
+                next.physicalName = source;
+            else
+                delete next.physicalName;
+            return next;
+        }
+        const shape = sourceFields[source], types = Array.isArray(shape?.type) ? shape.type : [shape?.type];
+        const type = types.find((value) => value !== "null");
+        const physicalType = {
+            string: "STRING",
+            integer: "BIGINT",
+            number: "DOUBLE",
+            boolean: "BOOLEAN",
+        }[String(type)];
+        check(physicalType, "MAPPING", `Source field ${source} needs an explicitly authored ODCS type`);
+        return {
+            name: target,
+            ...(source !== target ? { physicalName: source } : {}),
+            logicalType: type,
+            physicalType,
+            required: !types.includes("null"),
+        };
+    });
+    check(properties.length > 0, "MAPPING", "Select at least one source field");
+    doc.setIn(["schema", 0, "properties"], properties);
+    doc.set("status", "draft");
+    contractColumns(doc.toJS(), options.contract);
+    return preview(root, { [options.contract]: doc.toString() });
+}
 export function addTable(root, options) {
     const { file, doc } = flowFile(root, options.flow);
     check(doc.get("kind") === "ingestion", "FLOW", "table add requires an ingestion flow");

package/dist/core/connections.d.ts

@@ -14,6 +14,7 @@ export declare function prepareConnection(root: string, environment: string, flo
 } | {
     valid: boolean;
     specificationSha256: string;
+    sourceBoundarySha256: string;
     connection: string;
     flow: string;
 };

package/dist/core/connections.js

@@ -207,6 +207,13 @@ export function prepareConnection(root, environment, flowId, validateOnly = fals
         ? {
             valid: true,
             specificationSha256: input.specificationSha256,
+            sourceBoundarySha256: digest(canonical({
+                ...specification,
+                tables: Object.fromEntries(Object.entries(tables).map(([name, table]) => [
+                    name,
+                    table.source,
+                ])),
+            })),
             connection: input.connection,
             flow: flowId,
         }

package/dist/core/contracts.d.ts

@@ -1,6 +1,7 @@
 export declare function validateContract(contract: Record<string, any>, file?: string): void;
 export interface Column {
     name: string;
+    target?: string;
     type: string;
     required: boolean;
     key: boolean;

package/dist/core/contracts.js

@@ -14,12 +14,17 @@ export function contractColumns(contract, file) {
     validateContract(contract, file);
     check(contract.schema?.length === 1 && contract.schema[0].properties?.length, "ODCS", "A dataset contract must contain one table schema with columns", file);
     const names = new Set();
+    const targets = new Set();
     return contract.schema[0].properties.map((p) => {
         const name = p.physicalName ?? p.name;
         check(typeof name === "string" &&
             /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) &&
             !names.has(name), "ODCS", `Invalid or duplicate column ${name}`, file);
         names.add(name);
+        check(typeof p.name === "string" &&
+            /^[A-Za-z_][A-Za-z0-9_]*$/.test(p.name) &&
+            !targets.has(p.name), "ODCS", `Invalid or duplicate target column ${p.name}`, file);
+        targets.add(p.name);
         const type = (p.physicalType ??
             {
                 string: "STRING",
@@ -37,6 +42,7 @@ export function contractColumns(contract, file) {
         }
         return {
             name,
+            ...(p.name !== name ? { target: p.name } : {}),
             type,
             required: p.required === true,
             key: p.primaryKey === true,

package/dist/core/operations.d.ts

@@ -1,5 +1,46 @@
 import { z } from "zod";
 export declare const operationSchemas: {
+    readonly connection_add: z.ZodObject<{
+        id: z.ZodString;
+        package: z.ZodString;
+        sourceId: z.ZodString;
+        tenantId: z.ZodString;
+        binding: z.ZodOptional<z.ZodString>;
+        settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    readonly connection_flow_add: z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodString;
+        connection: z.ZodString;
+        table: z.ZodString;
+        contract: z.ZodString;
+        source: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        execution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    readonly contract_scaffold: z.ZodObject<{
+        id: z.ZodString;
+        table: z.ZodString;
+        field: z.ZodString;
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            integer: "integer";
+            number: "number";
+            string: "string";
+        }>;
+    }, z.core.$strict>;
+    readonly contract_map_fields: z.ZodObject<{
+        apiVersion: z.ZodLiteral<"ingestron.field-mapping/v1">;
+        flow: z.ZodString;
+        environment: z.ZodString;
+        contract: z.ZodString;
+        discovery: z.ZodString;
+        stream: z.ZodString;
+        table: z.ZodString;
+        fields: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            target: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
     readonly provider_scaffold: z.ZodObject<{
         id: z.ZodString;
         out: z.ZodString;

package/dist/core/operations.js

@@ -7,7 +7,7 @@ import { deliveryIndexSchema } from "./deliveries.js";
 import { existsSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
-import { check, Problem, canonical } from "./errors.js";
+import { check, Problem, canonical, digest } from "./errors.js";
 import { Configuration } from "./config.js";
 import { projectSchema, flowSchema, stepSchema, environmentSchema, } from "./schema.js";
 import { inspectProject, planProject } from "./planner.js";
@@ -24,6 +24,55 @@ import { providerVersions, friendlyReference } from "./package-references.js";
 import { browseProviders, pluginDetails } from "./installed-plugins.js";
 export const operationSchemas = {
     ...executionSchemas,
+    connection_add: z
+        .object({
+        id: workflows.identifier,
+        package: workflows.identifier,
+        sourceId: workflows.identifier,
+        tenantId: workflows.identifier,
+        binding: workflows.identifier.optional(),
+        settings: z.record(z.string(), z.unknown()).default({}),
+    })
+        .strict(),
+    connection_flow_add: z
+        .object({
+        id: workflows.identifier,
+        provider: workflows.identifier,
+        connection: workflows.identifier,
+        table: workflows.identifier,
+        contract: z.string().min(1),
+        source: z.record(z.string(), z.unknown()).default({}),
+        execution: z.record(z.string(), z.unknown()).optional(),
+    })
+        .strict(),
+    contract_scaffold: z
+        .object({
+        id: workflows.identifier,
+        table: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/),
+        field: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/),
+        type: z.enum(["string", "integer", "number", "boolean"]),
+    })
+        .strict(),
+    contract_map_fields: z
+        .object({
+        apiVersion: z.literal("ingestron.field-mapping/v1"),
+        flow: workflows.identifier,
+        environment: workflows.identifier,
+        contract: z.string().min(1),
+        discovery: z.string().min(1),
+        stream: z.string().min(1),
+        table: workflows.identifier,
+        fields: z
+            .array(z
+            .object({
+            source: workflows.identifier,
+            target: workflows.identifier,
+        })
+            .strict())
+            .min(1)
+            .max(500),
+    })
+        .strict(),
     provider_scaffold: z
         .object({ id: workflows.identifier, out: z.string() })
         .strict(),
@@ -308,6 +357,33 @@ export function execute(context, operation, request = {}) {
         const write = () => check(context.allowWrite, "PERMISSION", "This operation requires local-write access");
         let result;
         switch (operation) {
+            case "connection_add":
+                result = author.addConnection(root, args);
+                break;
+            case "connection_flow_add":
+                result = author.addConnectionFlow(root, args);
+                break;
+            case "contract_map_fields": {
+                check(args.environment === environment, "ENVIRONMENT", "Mapping draft is for another environment");
+                const prepared = prepareConnection(root, environment, args.flow, true);
+                const reader = new Configuration(root);
+                const discovery = JSON.parse(reader.text(args.discovery));
+                const discoveredSpec = discovery.identity?.projectSpecSha256;
+                if (discoveredSpec !== prepared.specificationSha256) {
+                    const saved = JSON.parse(reader.text(`build/generated/flows/${args.flow}/project-connection.lock.json`));
+                    const { specificationSha256: savedDigest, ...savedSpec } = saved;
+                    const sourceBoundary = {
+                        ...savedSpec,
+                        tables: Object.fromEntries(Object.entries(savedSpec.tables ?? {}).map(([name, table]) => [name, table.source])),
+                    };
+                    check(savedDigest === discoveredSpec &&
+                        savedDigest === digest(canonical(savedSpec)) &&
+                        digest(canonical(sourceBoundary)) ===
+                            prepared.sourceBoundarySha256, "DISCOVERY", "Source configuration changed since discovery; rebuild and rediscover before mapping fields");
+                }
+                result = author.mapContractFields(root, args);
+                break;
+            }
             case "runtime_prepare":
             case "run":
             case "run_status":
@@ -392,6 +468,9 @@ export function execute(context, operation, request = {}) {
             case "contract_create":
                 result = workflows.draftContract(root, environment, args);
                 break;
+            case "contract_scaffold":
+                result = author.scaffoldContract(root, args);
+                break;
             case "flow_create":
                 result = workflows.flowCreate(root, environment, args);
                 break;

package/dist/core/packages.d.ts

@@ -194,6 +194,7 @@ export declare function packageLock(root: string): {
     }>;
 };
 export declare function resolvePackage(root: string, reference: string): {
+    reference: string;
     file: string;
     root: string;
     entry: {

package/dist/core/packages.js

@@ -332,7 +332,7 @@ export function resolvePackage(root, reference) {
     check(canonical(inventory(cache)) === canonical(Object.keys(entry.files).sort()), "PACKAGE", "Package file inventory changed");
     for (const [file, hash] of Object.entries(entry.files))
         check(digest(readFileSync(fence(cache, file))) === hash, "PACKAGE", `Package integrity failed: ${file}`);
-    return { file: fence(cache, entry.path), root: cache, entry };
+    return { reference, file: fence(cache, entry.path), root: cache, entry };
 }
 /** Derived information lives outside the integrity-checked source cache. */
 export function savePluginInformation(root, reference) {

package/dist/core/workflows.js

@@ -182,12 +182,11 @@ export function pluginConfigure(root, args) {
         const connector = connectorPackageSchema.parse(sourceManifest);
         const { project, finish } = packageEditor(root);
         const name = identifier.parse(args.name ?? connector.id);
-        const at = reference.lastIndexOf("@");
         const raw = project.toJS();
         const friendly = preferredReference(root, raw, reference, connector.id, connector.version);
         const value = {
             source: friendly.slice(0, friendly.lastIndexOf("@")),
-            version: reference.slice(at + 1),
+            version: friendly.slice(friendly.lastIndexOf("@") + 1),
         };
         const previous = packageValue(raw, name);
         if (previous) {

package/dist/plugins/authoring.d.ts

@@ -1,4 +1,5 @@
 export declare function providerReference(root: string, reference: string): {
+    reference: string;
     file: string;
     root: string;
     entry: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingestron/core",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "type": "module",
   "description": "Shared Ingestron project compiler, operations and editor schemas",
   "license": "Apache-2.0",
@@ -45,6 +45,16 @@
     "type": "git",
     "url": "git+https://github.com/ingestron/core.git"
   },
+  "devDependencies": {
+    "@types/node": "22.20.1",
+    "prettier": "3.9.8",
+    "tsx": "4.23.13",
+    "typescript": "7.0.2"
+  },
+  "homepage": "https://ingestron.io",
+  "bugs": {
+    "url": "https://github.com/ingestron/core/issues"
+  },
   "scripts": {
     "build": "node scripts/build-assets.mjs && tsc && node scripts/compiler-fingerprint.mjs",
     "test": "tsx --test --test-concurrency=1 test/unit/*.test.ts test/providers/*.test.ts test/integration/*.test.ts",
@@ -54,19 +64,6 @@
     "release:check": "node scripts/release-check.mjs",
     "package:check": "tsx scripts/package-check.ts",
     "validate": "pnpm format:check && pnpm build && pnpm test && pnpm secrets:check && pnpm release:check && pnpm package:check",
-    "prepack": "npm run build",
-    "prepublishOnly": "node scripts/release-check.mjs --publish",
     "licences:inventory": "node scripts/licence-inventory.mjs"
-  },
-  "packageManager": "pnpm@10.15.0",
-  "devDependencies": {
-    "@types/node": "22.20.1",
-    "prettier": "3.9.8",
-    "tsx": "4.23.13",
-    "typescript": "7.0.2"
-  },
-  "homepage": "https://ingestron.io",
-  "bugs": {
-    "url": "https://github.com/ingestron/core/issues"
   }
-}
+}