better-supabase 0.8.0 → 0.10.0

package/dist/blocks/hiring/index.js

@@ -0,0 +1,180 @@
+import { t as AsyncResult } from "../../result-COkvI9t5.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as hiringSqlOptions } from "../../options-D2Gd6VfS.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, S as optionalInstant, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-BfVCR5Fc.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-ByKlh8Qy.js";
+import { n as blockFields } from "../../block-fields-BANwJ9Y_.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { i as refOf, n as compact } from "../../sales-shared-DjCuN8xG.js";
+//#region src/blocks/hiring/hiring.ts
+const JOB_STATUSES = [
+	"draft",
+	"open",
+	"closed"
+];
+const STATES = [
+	"active",
+	"hired",
+	"rejected",
+	"withdrawn"
+];
+const RECOMMENDATIONS = [
+	"strong_no",
+	"no",
+	"yes",
+	"strong_yes"
+];
+function jobOf(value) {
+	const row = recordOf(value, "job");
+	return compact({
+		id: textOf(row["id"]),
+		title: textOf(row["title"]),
+		teamId: optionalText(row["team_id"]),
+		location: optionalText(row["location"]),
+		employmentType: optionalText(row["employment_type"]),
+		description: optionalText(row["description"]),
+		hiringManagerId: optionalText(row["hiring_manager_user_id"]),
+		status: enumOrThrow(row["status"], JOB_STATUSES, "job status"),
+		openedAt: optionalInstant(row["opened_at"]),
+		closedAt: optionalInstant(row["closed_at"]),
+		fields: isRecord(row["fields"]) ? row["fields"] : {}
+	});
+}
+function applicationOf(value) {
+	const row = recordOf(value, "application");
+	return compact({
+		id: textOf(row["id"]),
+		jobId: textOf(row["job_id"]),
+		candidate: refOf(row["candidate_type"], row["candidate_id"]) ?? {
+			type: "",
+			id: ""
+		},
+		source: optionalText(row["source"]),
+		ownerId: optionalText(row["owner_user_id"]),
+		pipelineId: optionalText(row["pipeline_id"]),
+		stageId: optionalText(row["stage_id"]),
+		stageEnteredAt: optionalInstant(row["stage_entered_at"]),
+		state: enumOrThrow(row["state"], STATES, "application state"),
+		rejectionReason: optionalText(row["rejection_reason"]),
+		hiredAt: optionalInstant(row["hired_at"]),
+		createdAt: requiredInstant(row["created_at"], "createdAt")
+	});
+}
+function scorecardOf(value) {
+	const row = recordOf(value, "scorecard");
+	return compact({
+		id: textOf(row["id"]),
+		stageId: optionalText(row["stage_id"]),
+		reviewerId: textOf(row["reviewer_user_id"]),
+		rating: Number(row["rating"]),
+		recommendation: enumOrThrow(row["recommendation"], RECOMMENDATIONS, "recommendation"),
+		notes: optionalText(row["notes"]),
+		submittedAt: requiredInstant(row["submitted_at"], "submittedAt")
+	});
+}
+function interviewOf(value) {
+	const row = recordOf(value, "interview");
+	return compact({
+		id: textOf(row["id"]),
+		kind: optionalText(row["kind"]),
+		startsAt: requiredInstant(row["starts_at"], "startsAt"),
+		endsAt: requiredInstant(row["ends_at"], "endsAt"),
+		location: optionalText(row["location"]),
+		interviewerIds: Array.isArray(row["interviewer_user_ids"]) ? row["interviewer_user_ids"].map(String) : []
+	});
+}
+/**
+* The hiring block: jobs and applications on a pipeline per job, with
+* scorecards and interviews. Act on `application.hired` to create the
+* employee in your app.
+*/
+function createHiring(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "job fields");
+	const close = (applicationId, outcome, reason) => call("close_application", {
+		application: applicationId,
+		outcome,
+		reason: reason ?? null
+	}, applicationOf);
+	return withBlockHooks({
+		saveJob: (organizationId, job) => {
+			const { id, fields: extra, ...attrs } = job;
+			return AsyncResult.from(() => fields.write({ ...extra })).andThen((valid) => call("save_job", {
+				tenant: organizationId,
+				job: id ?? null,
+				attrs: extra === void 0 ? attrs : {
+					...attrs,
+					fields: valid
+				}
+			}, jobOf)).andThen((saved) => AsyncResult.from(() => fields.read(saved.fields)).map((value) => ({
+				...saved,
+				fields: value
+			})));
+		},
+		apply: (jobId, candidate, apply = {}) => call("apply_to_job", {
+			job: jobId,
+			candidate: { ...candidate },
+			source: apply.source ?? null,
+			owner: apply.ownerId ?? null
+		}, applicationOf),
+		hire: (applicationId) => close(applicationId, "hired"),
+		reject: (applicationId, reason) => close(applicationId, "rejected", reason),
+		withdraw: (applicationId) => close(applicationId, "withdrawn"),
+		score: (applicationId, card) => call("submit_scorecard", {
+			application: applicationId,
+			rating: card.rating,
+			recommendation: card.recommendation,
+			notes: card.notes ?? null
+		}, scorecardOf),
+		scheduleInterview: (applicationId, interview) => call("schedule_interview", {
+			application: applicationId,
+			starts_at: instantArg(interview.startsAt),
+			ends_at: instantArg(interview.endsAt),
+			interviewers: [...interview.interviewerIds ?? []],
+			kind: interview.kind ?? null,
+			location: interview.location ?? null
+		}, interviewOf),
+		detail: (applicationId) => call("application_detail", { application: applicationId }, (value) => {
+			const row = recordOf(value, "application_detail");
+			return compact({
+				...applicationOf(row),
+				scorecards: recordsOf(row["scorecards"], "scorecards").map(scorecardOf),
+				interviews: recordsOf(row["interviews"], "interviews").map(interviewOf),
+				averageRating: row["averageRating"] === null || row["averageRating"] === void 0 ? void 0 : Number(row["averageRating"])
+			});
+		})
+	}, options.hooks, {
+		block: "hiring",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/hiring/events.ts
+/** The `hiring` block's event types, for its manifest and `onBlockEvent`. */
+const hiringEvents = defineEvents({
+	"job.opened": event(),
+	"job.closed": event(),
+	"application.created": event(),
+	"application.hired": event(),
+	"application.rejected": event(),
+	"application.retracted": event(),
+	"scorecard.submitted": event(),
+	"interview.scheduled": event()
+});
+//#endregion
+//#region src/blocks/hiring/manifest.ts
+/** The `hiring` block's manifest (ADR 0029). */
+const hiringBlock = defineBlock({
+	name: "hiring",
+	sql: ["hiring"],
+	options: { hiring: hiringSqlOptions },
+	events: hiringEvents,
+	create: createHiring,
+	category: "people",
+	recipes: ["hiring-board"]
+});
+//#endregion
+export { createHiring, dbTransport, extendBlock, hiringBlock, hiringEvents, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/identities/index.d.ts

@@ -0,0 +1,83 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "../../block-hooks-C_WaodoA.js";
+import { d as IdentityRef, f as IdentityTarget, p as PrincipalByIdentity } from "../../authorization-hooks-Do5djkpz.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+//#region src/blocks/identities/identities.d.ts
+interface IdentitiesOptions extends BlockTemporalOptions {
+  /**
+   * `sqlTransport(postgres.asUser(claims))` for `beginLink`, `list` and
+   * `unlink`; a service transport for `redeemLink`, `resolve` and
+   * `backfillVerifiedEmails`.
+   */
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around the methods (ADR 0015). */
+  readonly hooks?: NoInfer<BlockHooks<Identities>>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+/** A one-time code from `beginLink`. Only its SHA-256 is stored. */
+interface LinkCode {
+  readonly code: string;
+  readonly expiresAt: Temporal.Instant;
+}
+/** The link `redeemLink` created or found. */
+interface RedeemedLink {
+  readonly id: string;
+  readonly userId: string;
+}
+type IdentitySource = "link" | "verified_email";
+/** One of the caller's identities. */
+interface LinkedIdentity {
+  readonly id: string;
+  readonly kind: IdentityRef["kind"];
+  readonly provider: string | null;
+  readonly value: string;
+  readonly workspace: string | null;
+  readonly source: IdentitySource;
+  readonly createdAt: Temporal.Instant;
+}
+/** The `identities` SQL module as typed calls. */
+interface Identities {
+  /** Signed-in user: issues a one-time code for the bot or the mail side to redeem. */
+  readonly beginLink: (kind: IdentityRef["kind"], provider?: string) => AsyncResult<LinkCode>;
+  /**
+   * Service role: binds `identity` to the user who issued `code`. Pass only
+   * an identity the platform authenticated, such as the author of a signed
+   * Slack event or a DKIM-verified sender.
+   */
+  readonly redeemLink: (code: string, identity: IdentityRef) => AsyncResult<RedeemedLink>;
+  /** Service role: the user or contact `identity` is linked to, or `null`. */
+  readonly resolve: (identity: IdentityRef) => AsyncResult<IdentityTarget | null>;
+  /** The caller's identities, oldest first. */
+  readonly list: () => AsyncResult<readonly LinkedIdentity[]>;
+  /** Removes one of the caller's identities; `false` when the caller has none with `id`. */
+  readonly unlink: (id: string) => AsyncResult<boolean>;
+  /** Service role: email identities for users confirmed before the module was installed. */
+  readonly backfillVerifiedEmails: () => AsyncResult<number>;
+}
+export declare function createIdentities(options: IdentitiesOptions): Identities;
+/**
+ * A `PrincipalByIdentity` over the `identities` table, for
+ * `createServer(bs, { authorization: { identities: { principalByIdentity } } })`
+ * or a chat helper's `principalByIdentity` option. `transport` runs as the
+ * service role. A database error rejects, so the caller retries instead of
+ * treating a linked author as anonymous.
+ */
+export declare function identityResolver(transport: BlockTransport, options?: Omit<IdentitiesOptions, "transport">): PrincipalByIdentity;
+/** `createIdentities({ transport }).beginLink(kind, provider)`, as the signed-in user. */
+export declare function beginLink(transport: BlockTransport, kind: IdentityRef["kind"], provider?: string): AsyncResult<LinkCode>;
+/** `createIdentities({ transport }).redeemLink(code, identity)`, as the service role. */
+export declare function redeemLink(transport: BlockTransport, code: string, identity: IdentityRef): AsyncResult<RedeemedLink>;
+//#endregion
+//#region src/blocks/identities/manifest.d.ts
+/** The `identities` block's manifest (ADR 0029). */
+export declare const identitiesBlock: BlockOf<"identities", typeof createIdentities>;
+//#endregion
+export { type BlockTransport, type Identities, type IdentitiesOptions, type IdentityRef, type IdentitySource, type IdentityTarget, type LinkCode, type LinkedIdentity, type PrincipalByIdentity, type RedeemedLink, dbTransport, rpcTransport, sqlTransport };

package/dist/blocks/identities/index.js

@@ -0,0 +1,103 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as identitiesSqlOptions } from "../../options-CXFz0xxS.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { A as requiredInstant, D as recordOf, I as textOf, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall, y as nullableText } from "../../block-helpers-BfVCR5Fc.js";
+import { r as withBlockHooks } from "../../block-hooks-ByKlh8Qy.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+//#region src/blocks/identities/identities.ts
+const KINDS = ["email", "chat"];
+const SOURCES = ["link", "verified_email"];
+/** The `principal_by_identity` result, or `null` for anything that names no one. */
+function targetOf(value) {
+	if (!isRecord(value)) return null;
+	if (value["kind"] === "user" && typeof value["userId"] === "string") return {
+		kind: "user",
+		userId: value["userId"]
+	};
+	if (value["kind"] === "contact" && typeof value["contactId"] === "string") return {
+		kind: "contact",
+		contactId: value["contactId"]
+	};
+	return null;
+}
+const identityArgs = (identity) => ({
+	kind: identity.kind,
+	provider: identity.provider ?? null,
+	value: identity.value,
+	workspace: identity.workspace ?? null
+});
+function createIdentities(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return withBlockHooks({
+		beginLink: (kind, provider) => call("begin_identity_link", {
+			kind,
+			provider: provider ?? null
+		}, (value) => {
+			const row = recordOf(value, "begin_identity_link");
+			return {
+				code: textOf(row["code"]),
+				expiresAt: requiredInstant(row["expires_at"], "expires_at")
+			};
+		}),
+		redeemLink: (code, identity) => call("redeem_identity_link", {
+			code,
+			...identityArgs(identity)
+		}, (value) => {
+			const row = recordOf(value, "redeem_identity_link");
+			return {
+				id: textOf(row["id"]),
+				userId: textOf(row["user_id"])
+			};
+		}),
+		resolve: (identity) => call("principal_by_identity", identityArgs(identity), targetOf),
+		list: () => call("my_identities", {}, (value) => recordsOf(value, "my_identities").map((row) => ({
+			id: textOf(row["id"]),
+			kind: enumOrThrow(row["kind"], KINDS, "identity kind"),
+			provider: nullableText(row["provider"]),
+			value: textOf(row["value"]),
+			workspace: nullableText(row["workspace"]),
+			source: enumOrThrow(row["source"], SOURCES, "identity source"),
+			createdAt: requiredInstant(row["created_at"], "created_at")
+		}))),
+		unlink: (id) => call("unlink_identity", { id }, (value) => value === true),
+		backfillVerifiedEmails: () => call("backfill_verified_emails", {}, (value) => typeof value === "number" ? value : Number(value))
+	}, options.hooks, {
+		block: "identities",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+/**
+* A `PrincipalByIdentity` over the `identities` table, for
+* `createServer(bs, { authorization: { identities: { principalByIdentity } } })`
+* or a chat helper's `principalByIdentity` option. `transport` runs as the
+* service role. A database error rejects, so the caller retries instead of
+* treating a linked author as anonymous.
+*/
+function identityResolver(transport, options = {}) {
+	const identities = createIdentities({
+		...options,
+		transport
+	});
+	return (identity) => identities.resolve(identity).orThrow();
+}
+/** `createIdentities({ transport }).beginLink(kind, provider)`, as the signed-in user. */
+function beginLink(transport, kind, provider) {
+	return createIdentities({ transport }).beginLink(kind, provider);
+}
+/** `createIdentities({ transport }).redeemLink(code, identity)`, as the service role. */
+function redeemLink(transport, code, identity) {
+	return createIdentities({ transport }).redeemLink(code, identity);
+}
+//#endregion
+//#region src/blocks/identities/manifest.ts
+/** The `identities` block's manifest (ADR 0029). */
+const identitiesBlock = defineBlock({
+	name: "identities",
+	sql: ["identities"],
+	options: { identities: identitiesSqlOptions },
+	create: createIdentities,
+	category: "identity"
+});
+//#endregion
+export { beginLink, createIdentities, dbTransport, identitiesBlock, identityResolver, redeemLink, rpcTransport, sqlTransport };

package/dist/blocks/imports/index.d.ts

@@ -0,0 +1,159 @@
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { B as TableMeta } from "../../types-BO8lVTun.js";
+import { $ as SaasEventData, wt as Events } from "../../events-CtAHxPal.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as BlockTransport } from "../../block-transport-NbUJygA7.js";
+import { n as BlockHooks } from "../../block-hooks-C_WaodoA.js";
+import { s as BlockOf } from "../../define-block-BlHQxDIQ.js";
+import { r as parseCsv } from "../../csv-D3eKxV1T.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/blocks/imports/define-import.d.ts
+interface ImportColumn {
+  readonly name: string;
+  readonly label?: string;
+}
+interface ImportDefinition<T> {
+  readonly kind: string;
+  readonly columns: StandardSchemaV1<unknown, T>;
+  /** Stable id of a row, so a rerun skips a row that already imported. */
+  readonly key: (row: T) => string;
+  readonly insert: (batch: readonly T[], ctx: {
+    readonly organizationId: string;
+  }) => Promise<void>;
+}
+interface ImportRowError {
+  readonly row: number;
+  readonly message: string;
+}
+interface DryRunResult<T> {
+  readonly rows: readonly T[];
+  readonly errors: readonly ImportRowError[];
+}
+/** Registers an import. `runImport` calls `insert` in batches. */
+export declare function defineImport<T>(definition: ImportDefinition<T>): ImportDefinition<T>;
+/**
+ * Pairs CSV headers with import fields. A header matches a field when they
+ * are equal after lowercasing and dropping spaces and underscores.
+ */
+export declare function suggestMapping(headers: readonly string[], fields: readonly string[]): Readonly<Record<string, string | undefined>>;
+/**
+ * Parses CSV, applies `mapping` (CSV header to field name) and validates
+ * every row. Nothing is written.
+ */
+export declare function dryRun<T>(definition: ImportDefinition<T>, csv: string, mapping: Readonly<Record<string, string>>): Promise<DryRunResult<T>>;
+interface RunImportResult<T> {
+  readonly id: string;
+  readonly status: "completed" | "failed";
+  readonly imported: number;
+  readonly errors: readonly ImportRowError[];
+  readonly rows: readonly T[];
+}
+/**
+ * Validates the file, skips rows whose key was already imported, inserts the
+ * rest in batches and finishes the run as `import.completed` or `import.failed`.
+ * A batch that throws finishes the run as failed with the rows inserted so
+ * far, and the result says so instead of the error escaping.
+ */
+export declare function runImport<T>(definition: ImportDefinition<T>, csv: string, mapping: Readonly<Record<string, string>>, hooks: {
+  readonly organizationId: string;
+  readonly importedKeys?: ReadonlySet<string>;
+  readonly start: () => Promise<string>;
+  /** Marks the run `running` before the first batch (`mark_import_running`). */
+  readonly running?: (id: string) => Promise<void>;
+  readonly finish: (id: string, status: "completed" | "failed", count: number, error: string | null) => Promise<void>;
+}): Promise<RunImportResult<T>>;
+//#endregion
+//#region src/blocks/imports/app-table-import.d.ts
+type Values = Readonly<Record<string, unknown>>;
+/**
+ * The repository methods an upsert import uses. A generated repository
+ * (`db.tasks`) fits it.
+ */
+interface AppTableImportRepository<T extends object, K extends Extract<keyof T, string>> {
+  readonly $meta: TableMeta;
+  findMany(args: {
+    readonly where: {
+      readonly OR: readonly Pick<T, K>[];
+    };
+  }): AsyncResult<readonly Values[]>;
+  upsertMany(rows: readonly T[], args: {
+    readonly onConflict: readonly K[];
+    readonly returning: false;
+  }): AsyncResult<unknown>;
+}
+/**
+ * How an import treats a row that already exists: `fill` writes only the
+ * fields that are empty in the database, `overwrite` writes every field
+ * the file has.
+ */
+type AppTableImportUpdate = "fill" | "overwrite";
+interface AppTableImportOptions<T extends object, K extends Extract<keyof T, string>> {
+  /** The app table's name, the import's `kind`. */
+  readonly table: string;
+  readonly columns: StandardSchemaV1<unknown, T>;
+  readonly repository: AppTableImportRepository<NoInfer<T>, NoInfer<K>>;
+  /** One of the table's unique sets (or its primary key) that finds an existing row. */
+  readonly key: readonly K[];
+  /** Defaults to `fill`. */
+  readonly update?: AppTableImportUpdate;
+}
+interface ImportPreview {
+  /** Rows the import inserts. */
+  readonly created: number;
+  /** Existing rows the import changes. */
+  readonly changed: number;
+  /** Existing rows the import leaves as they are. */
+  readonly unchanged: number;
+}
+/** An import that upserts into an app table; `runImport` and `previewImport` take it. */
+interface AppTableImport<T extends object> extends ImportDefinition<T> {
+  /** Counts the rows the import creates, changes and leaves; writes nothing. */
+  readonly preview: (rows: readonly T[]) => Promise<ImportPreview>;
+}
+/**
+ * An import that upserts rows into an app table on one of its unique sets.
+ * A row whose key exists updates that row (see `update`); the rest are
+ * inserted. Pass no `importedKeys` to `runImport`, so a rerun updates rows
+ * instead of skipping them.
+ */
+export declare function appTableImport<T extends object, K extends Extract<keyof T, string>>(options: AppTableImportOptions<T, K>): AppTableImport<T>;
+interface PreviewImportResult<T> extends DryRunResult<T> {
+  readonly preview: ImportPreview;
+}
+/**
+ * Validates the file like `dryRun`, then counts the valid rows the import
+ * would create, change and leave unchanged. Nothing is written.
+ */
+export declare function previewImport<T extends object>(definition: AppTableImport<T>, csv: string, mapping: Readonly<Record<string, string>>): Promise<PreviewImportResult<T>>;
+//#endregion
+//#region src/blocks/imports/imports.d.ts
+interface ImportsOptions {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around the methods (ADR 0015). */
+  readonly hooks?: NoInfer<BlockHooks<Imports>>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+interface Imports {
+  start(organizationId: string, kind: string, mapping?: Readonly<Record<string, string>>): AsyncResult<{
+    readonly id: string;
+  }>;
+}
+export declare function createImports(options: ImportsOptions): Imports;
+//#endregion
+//#region src/blocks/imports/events.d.ts
+/** The events of the `imports` block: type to data. */
+type ImportsEvents = {
+  readonly "import.completed": SaasEventData;
+  readonly "import.failed": SaasEventData;
+};
+/** The `imports` block's event types, for its manifest and `onBlockEvent`. */
+export declare const importsEvents: Events<ImportsEvents>;
+//#endregion
+//#region src/blocks/imports/manifest.d.ts
+/** The `imports` block's manifest (ADR 0029). */
+export declare const importsBlock: BlockOf<"imports", typeof createImports, ImportsEvents>;
+//#endregion
+export { type AppTableImport, type AppTableImportOptions, type AppTableImportRepository, type AppTableImportUpdate, type DryRunResult, type ImportColumn, type ImportDefinition, type ImportPreview, type ImportRowError, type Imports, type ImportsEvents, type ImportsOptions, type PreviewImportResult, type RunImportResult, parseCsv };