@kelpie/server 0.1.0

package/dist/modules/import-export/schema.d.ts

@@ -0,0 +1,494 @@
+import type { ImportCounts, ImportPreviewRow, ImportRowError } from '@kelpie/schemas';
+/**
+ * The fixed value sets come from `@kelpie/schemas`, so these check constraints,
+ * the route's Zod enums, and the browser's decoder are one list rather than
+ * three copies.
+ */
+export { IMPORT_CONFLICT_MODES, IMPORT_JOB_STATUSES, IMPORT_OBJECTS, IMPORT_ROW_ACTIONS, IMPORT_SOURCES, } from '@kelpie/schemas';
+export type { ImportConflictMode, ImportJobStatus, ImportObject, ImportRowAction, ImportSource, SettledRowAction, } from '@kelpie/schemas';
+/** One problem with one cell, as stored against the row that carries it. */
+export interface StoredRowError {
+    readonly field: string;
+    readonly message: string;
+}
+/**
+ * A CSV import, from upload through dry run to commit.
+ *
+ * `column_map`, `counts`, `errors` and `preview` are jsonb because their shape
+ * follows the object being imported and nothing queries into them.
+ *
+ * A job stores no part of the file. The upload plans it in memory and keeps
+ * `counts`, `errors`, `preview` and `file_sha256`; the caller keeps the file and
+ * hands it back at commit. That is what makes an abandoned dry run cost one row
+ * rather than a copy of a ten megabyte upload, and it is why nothing is exploded
+ * into `import_job_rows` until an import actually runs.
+ *
+ * `file_name` is what the uploader called the file, for the mapping screen.
+ */
+export declare const importJobs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "import_jobs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        object: import("drizzle-orm/pg-core").PgColumn<{
+            name: "object";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        conflictMode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "conflict_mode";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        matchKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "match_key";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        columnMap: import("drizzle-orm/pg-core").PgColumn<{
+            name: "column_map";
+            tableName: "import_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Readonly<Record<string, string | null>>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Readonly<Record<string, string | null>>;
+        }>;
+        sourceHeaders: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_headers";
+            tableName: "import_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: readonly string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: readonly string[];
+        }>;
+        counts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "counts";
+            tableName: "import_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ImportCounts;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ImportCounts;
+        }>;
+        errors: import("drizzle-orm/pg-core").PgColumn<{
+            name: "errors";
+            tableName: "import_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: readonly ImportRowError[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: readonly ImportRowError[];
+        }>;
+        preview: import("drizzle-orm/pg-core").PgColumn<{
+            name: "preview";
+            tableName: "import_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: readonly ImportPreviewRow[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: readonly ImportPreviewRow[];
+        }>;
+        fileSha256: import("drizzle-orm/pg-core").PgColumn<{
+            name: "file_sha256";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fileName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "file_name";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failureReason: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failure_reason";
+            tableName: "import_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "import_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "import_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+/**
+ * What an import did to one line of the file.
+ *
+ * Written by the commit, one row at a time, in the same transaction as the
+ * record that row wrote. Nothing here exists before then: a dry run forecasts
+ * without storing, so a caller who corrects a mapping four times leaves four
+ * jobs and no rows rather than four copies of the file.
+ *
+ * `action` is therefore always what happened, never a forecast. `values` holds
+ * the line as it arrived — **source header → cell** — so the row says what it
+ * acted on without the reader having to go back to `import_jobs.csv` and count
+ * lines.
+ */
+export declare const importJobRows: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "import_job_rows";
+    schema: undefined;
+    columns: {
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "import_job_rows";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        jobId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_id";
+            tableName: "import_job_rows";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rowNumber: import("drizzle-orm/pg-core").PgColumn<{
+            name: "row_number";
+            tableName: "import_job_rows";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        values: import("drizzle-orm/pg-core").PgColumn<{
+            name: "values";
+            tableName: "import_job_rows";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Readonly<Record<string, string>>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Readonly<Record<string, string>>;
+        }>;
+        action: import("drizzle-orm/pg-core").PgColumn<{
+            name: "action";
+            tableName: "import_job_rows";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        errors: import("drizzle-orm/pg-core").PgColumn<{
+            name: "errors";
+            tableName: "import_job_rows";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: readonly StoredRowError[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: readonly StoredRowError[];
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "import_job_rows";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "import_job_rows";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/modules/import-export/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/modules/import-export/schema.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACf,MAAM,iBAAiB,CAAA;AAMxB;;;;GAIG;AACH,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,cAAc,GACf,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,gBAAgB,GACjB,MAAM,iBAAiB,CAAA;AAExB,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CtB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBzB,CAAA"}

package/dist/modules/import-export/schema.js

@@ -0,0 +1,99 @@
+import { IMPORT_CONFLICT_MODES, IMPORT_JOB_STATUSES, IMPORT_OBJECTS, IMPORT_ROW_ACTIONS, IMPORT_SOURCES, } from '@kelpie/schemas';
+import { index, integer, jsonb, pgTable, primaryKey, text } from 'drizzle-orm/pg-core';
+import { checkOneOf, createdAt, primaryId, updatedAt } from '../../lib/columns.js';
+import { workspaces } from '../workspace/schema.js';
+/**
+ * The fixed value sets come from `@kelpie/schemas`, so these check constraints,
+ * the route's Zod enums, and the browser's decoder are one list rather than
+ * three copies.
+ */
+export { IMPORT_CONFLICT_MODES, IMPORT_JOB_STATUSES, IMPORT_OBJECTS, IMPORT_ROW_ACTIONS, IMPORT_SOURCES, } from '@kelpie/schemas';
+/**
+ * A CSV import, from upload through dry run to commit.
+ *
+ * `column_map`, `counts`, `errors` and `preview` are jsonb because their shape
+ * follows the object being imported and nothing queries into them.
+ *
+ * A job stores no part of the file. The upload plans it in memory and keeps
+ * `counts`, `errors`, `preview` and `file_sha256`; the caller keeps the file and
+ * hands it back at commit. That is what makes an abandoned dry run cost one row
+ * rather than a copy of a ten megabyte upload, and it is why nothing is exploded
+ * into `import_job_rows` until an import actually runs.
+ *
+ * `file_name` is what the uploader called the file, for the mapping screen.
+ */
+export const importJobs = pgTable('import_jobs', {
+    id: primaryId(),
+    workspaceId: text('workspace_id')
+        .notNull()
+        .references(() => workspaces.id, { onDelete: 'cascade' }),
+    source: text('source').notNull(),
+    object: text('object').notNull(),
+    status: text('status').notNull(),
+    conflictMode: text('conflict_mode').notNull(),
+    matchKey: text('match_key').notNull(),
+    columnMap: jsonb('column_map').$type().notNull().default({}),
+    sourceHeaders: jsonb('source_headers').$type().notNull().default([]),
+    counts: jsonb('counts').$type().notNull(),
+    /** The first `IMPORT_REPORTED_ERRORS` failing rows. `counts.error` is the true number. */
+    errors: jsonb('errors').$type().notNull().default([]),
+    /** The first `IMPORT_PREVIEW_ROWS` rows, mapped as Kelpie read them. */
+    preview: jsonb('preview').$type().notNull().default([]),
+    /**
+     * SHA-256 of the file this job forecast, hex.
+     *
+     * The file itself is not kept. The commit carries it back and is refused if
+     * it hashes to anything else, which buys the same "this is the file you
+     * approved" guarantee as storing it for 64 characters instead of up to ten
+     * megabytes. Null only on a job from before this, which cannot be committed;
+     * the remedy is the one `import-export.md` already gives — upload it again.
+     */
+    fileSha256: text('file_sha256'),
+    fileName: text('file_name'),
+    /** Why a background pass gave up. Null unless `status` is `failed`. */
+    failureReason: text('failure_reason'),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (table) => [
+    index('import_jobs_workspace_idx').on(table.workspaceId),
+    checkOneOf('import_jobs_source_check', table.source, IMPORT_SOURCES),
+    checkOneOf('import_jobs_object_check', table.object, IMPORT_OBJECTS),
+    checkOneOf('import_jobs_conflict_mode_check', table.conflictMode, IMPORT_CONFLICT_MODES),
+    checkOneOf('import_jobs_status_check', table.status, IMPORT_JOB_STATUSES),
+]);
+/**
+ * What an import did to one line of the file.
+ *
+ * Written by the commit, one row at a time, in the same transaction as the
+ * record that row wrote. Nothing here exists before then: a dry run forecasts
+ * without storing, so a caller who corrects a mapping four times leaves four
+ * jobs and no rows rather than four copies of the file.
+ *
+ * `action` is therefore always what happened, never a forecast. `values` holds
+ * the line as it arrived — **source header → cell** — so the row says what it
+ * acted on without the reader having to go back to `import_jobs.csv` and count
+ * lines.
+ */
+export const importJobRows = pgTable('import_job_rows', {
+    workspaceId: text('workspace_id')
+        .notNull()
+        .references(() => workspaces.id, { onDelete: 'cascade' }),
+    jobId: text('job_id')
+        .notNull()
+        .references(() => importJobs.id, { onDelete: 'cascade' }),
+    /** The line in the file, counting the header as line 1. Data starts at 2. */
+    rowNumber: integer('row_number').notNull(),
+    values: jsonb('values').$type().notNull().default({}),
+    action: text('action').notNull(),
+    errors: jsonb('errors').$type().notNull().default([]),
+    createdAt: createdAt(),
+    updatedAt: updatedAt(),
+}, (table) => [
+    // The job and the line already identify a row, so it needs no id of its own.
+    // A `<prefix>_<ulid>` here would also mean a prefix `api.md` does not
+    // document, for something that never appears on the wire.
+    primaryKey({ columns: [table.jobId, table.rowNumber] }),
+    index('import_job_rows_workspace_idx').on(table.workspaceId),
+    checkOneOf('import_job_rows_action_check', table.action, IMPORT_ROW_ACTIONS),
+]);
+//# sourceMappingURL=schema.js.map

package/dist/modules/import-export/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/modules/import-export/schema.ts"],"names":[],"mappings":"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"}

package/dist/modules/import-export/service.d.ts

@@ -0,0 +1,74 @@
+import type { ImportColumnMap, ImportConflictMode, ImportCounts, ImportObject, ImportPreviewRow, ImportRowError, ImportSource } from '@kelpie/schemas';
+import type { Database } from '../../lib/database.ts';
+import type { IdFactory } from '../../lib/ids.ts';
+import type { Logger } from '../../lib/logger.ts';
+import type { TransactionScope } from '../../runtime/transaction.ts';
+import type { ActivityRecorder } from '../activities/recorder.ts';
+import type { Actor } from '../auth/actor.ts';
+/**
+ * CSV import jobs and CSV export, per `import-export.md`.
+ *
+ * The shape of a job is: upload, which stores the file; a dry run, which plans
+ * each line against the workspace and reports what would happen; then a commit,
+ * which applies the file while re-resolving every match. Re-resolving is the
+ * point — the workspace can change between the two calls, and lines earlier in
+ * the same file create records later lines must match against. It is also what
+ * makes a commit idempotent: run it twice and the second pass finds the records
+ * the first one made.
+ *
+ * Only the commit writes `import_job_rows`. A dry run plans from the stored file
+ * in memory and keeps nothing but its counts, its first errors and its preview,
+ * because a forecast nobody committed is not a thing to store ten thousand rows
+ * for. That is also why a corrected mapping — which is a new job over the same
+ * file — costs one row rather than the file again.
+ */
+export interface ImportExportDependencies {
+    readonly db: Database;
+    readonly transaction: TransactionScope;
+    readonly createId: IdFactory;
+    readonly now: () => Date;
+    readonly recordActivity: ActivityRecorder;
+    readonly log: Logger;
+}
+/** A job as the API returns one: the stored row minus tenancy, with its errors and preview. */
+export interface ImportJobView {
+    readonly id: string;
+    readonly source: ImportSource;
+    readonly object: ImportObject;
+    readonly status: string;
+    readonly conflictMode: ImportConflictMode;
+    readonly matchKey: string;
+    readonly columnMap: ImportColumnMap;
+    readonly sourceHeaders: readonly string[];
+    readonly fileName: string | null;
+    readonly counts: ImportCounts;
+    readonly errors: readonly ImportRowError[];
+    readonly preview: readonly ImportPreviewRow[];
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+export interface CreateImportJobInput {
+    readonly source: ImportSource;
+    readonly object: ImportObject;
+    readonly conflictMode: ImportConflictMode;
+    readonly matchKeyId: string;
+    /** Absent means "derive one from the source preset and the file's own headers". */
+    readonly columnMap: ImportColumnMap | undefined;
+    readonly fileName: string | null;
+    readonly csv: string;
+}
+export interface ImportExportService {
+    createJob(actor: Actor, input: CreateImportJobInput): Promise<ImportJobView>;
+    getJob(actor: Actor, id: string): Promise<ImportJobView>;
+    /**
+     * @param csv The same file the dry run read. A job holds only its digest, so
+     *   the caller brings the bytes back and a different file is refused.
+     */
+    commit(actor: Actor, id: string, csv: string): Promise<ImportJobView>;
+    deleteJob(actor: Actor, id: string): Promise<void>;
+    /** CSV lines for a whole object, a page of records at a time. */
+    exportCsv(actor: Actor, object: ImportObject): AsyncGenerator<string>;
+    templateCsv(object: ImportObject): string;
+}
+export declare function createImportExportService(dependencies: ImportExportDependencies): ImportExportService;
+//# sourceMappingURL=service.d.ts.map

package/dist/modules/import-export/service.d.ts.map

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