@chelone/core 0.6.0 → 0.9.0

package/dist/csv/run-import.js

@@ -1,76 +1,73 @@
+// src/csv/run-import.ts
+/**
+* Creates the valid rows `batchSize` at a time, each with its own `create`
+* call, since `DataProvider` has no bulk create. A rejected create is recorded
+* and the import goes on. An aborted `signal` stops before the next batch.
+*/
 async function runCsvImport(options) {
-  const {
-    dataProvider,
-    resource,
-    validations,
-    batchSize = 100,
-    signal,
-    onProgress
-  } = options;
-  if (!(batchSize >= 1)) {
-    throw new RangeError(`batchSize must be at least 1, got ${batchSize}`);
-  }
-  const size = Math.floor(batchSize);
-  const errors = [];
-  const valid = [];
-  validations.forEach((validation, rowIndex) => {
-    if (validation.ok) valid.push({ rowIndex, row: validation.row });
-    else {
-      errors.push({
-        rowIndex,
-        row: validation.row,
-        reason: validation.issues.join("; ")
-      });
-    }
-  });
-  let created = 0;
-  let current = 0;
-  let aborted = false;
-  for (let start = 0; start < valid.length; start += size) {
-    if (signal?.aborted) {
-      aborted = true;
-      break;
-    }
-    const batch = valid.slice(start, start + size);
-    const results = await Promise.allSettled(
-      batch.map(({ row }) => dataProvider.create(resource, { data: row }))
-    );
-    results.forEach((result, i) => {
-      if (result.status === "fulfilled") {
-        created += 1;
-        return;
-      }
-      const { rowIndex, row } = batch[i];
-      errors.push({
-        rowIndex,
-        row,
-        reason: result.reason instanceof Error ? result.reason.message : String(result.reason)
-      });
-    });
-    current += batch.length;
-    onProgress?.({ current, total: valid.length });
-  }
-  errors.sort((a, b) => a.rowIndex - b.rowIndex);
-  return {
-    total: validations.length,
-    created,
-    failed: errors.length,
-    errors,
-    aborted
-  };
+	const { dataProvider, resource, validations, batchSize = 100, signal, onProgress } = options;
+	if (!(batchSize >= 1)) throw new RangeError(`batchSize must be at least 1, got ${batchSize}`);
+	const size = Math.floor(batchSize);
+	const errors = [];
+	const valid = [];
+	validations.forEach((validation, rowIndex) => {
+		if (validation.ok) valid.push({
+			rowIndex,
+			row: validation.row
+		});
+		else errors.push({
+			rowIndex,
+			row: validation.row,
+			reason: validation.issues.join("; ")
+		});
+	});
+	let created = 0;
+	let current = 0;
+	let aborted = false;
+	for (let start = 0; start < valid.length; start += size) {
+		if (signal?.aborted) {
+			aborted = true;
+			break;
+		}
+		const batch = valid.slice(start, start + size);
+		(await Promise.allSettled(batch.map(({ row }) => dataProvider.create(resource, { data: row })))).forEach((result, i) => {
+			if (result.status === "fulfilled") {
+				created += 1;
+				return;
+			}
+			const item = batch[i];
+			if (!item) return;
+			const { rowIndex, row } = item;
+			errors.push({
+				rowIndex,
+				row,
+				reason: result.reason instanceof Error ? result.reason.message : String(result.reason)
+			});
+		});
+		current += batch.length;
+		onProgress?.({
+			current,
+			total: valid.length
+		});
+	}
+	errors.sort((a, b) => a.rowIndex - b.rowIndex);
+	return {
+		total: validations.length,
+		created,
+		failed: errors.length,
+		errors,
+		aborted
+	};
 }
+/**
+* One flat row per error, `rowIndex` and `reason` first, for the error
+* download. A row field named `rowIndex` or `reason` loses to the real values.
+*/
 function csvErrorRows(report) {
-  return report.errors.map(({ rowIndex, reason, row }) => ({
-    rowIndex,
-    reason,
-    ...Object.fromEntries(
-      Object.entries(row).filter(
-        ([key]) => key !== "rowIndex" && key !== "reason"
-      )
-    )
-  }));
+	return report.errors.map(({ rowIndex, reason, row }) => ({
+		rowIndex,
+		reason,
+		...Object.fromEntries(Object.entries(row).filter(([key]) => key !== "rowIndex" && key !== "reason"))
+	}));
 }
-export {
-  csvErrorRows,
-  runCsvImport
-};
+export { csvErrorRows, runCsvImport };

package/dist/csv/validate-rows.d.ts

@@ -6,7 +6,7 @@ export declare function applyCsvMapping(row: Record<string, unknown>, mapping: R
  * Lists a zod object's keys, and the ones whose schema is not optional. Any
  * other schema has no `shape` to read and yields no fields.
  */
-export declare function csvSchemaFields(schema: unknown): {
+export declare function csvSchemaFields(schema: StandardSchemaV1 | undefined): {
     fields: string[];
     required: string[];
 };

package/dist/csv/validate-rows.js

@@ -1,58 +1,71 @@
+// src/csv/validate-rows.ts
+/** Copies `row[header]` to `field` for each mapping entry; a field mapped to `""` is skipped. */
 function applyCsvMapping(row, mapping) {
-  return Object.fromEntries(
-    Object.entries(mapping).filter(([, header]) => header !== "").map(([field, header]) => [field, row[header]])
-  );
+	return Object.fromEntries(Object.entries(mapping).filter(([, header]) => header !== "").map(([field, header]) => [field, row[header]]));
 }
+/**
+* Lists a zod object's keys, and the ones whose schema is not optional. Any
+* other schema has no `shape` to read and yields no fields.
+*/
 function csvSchemaFields(schema) {
-  const shape = schema?.shape;
-  if (typeof shape !== "object" || shape === null) {
-    return { fields: [], required: [] };
-  }
-  const entries = Object.entries(shape);
-  return {
-    fields: entries.map(([key]) => key),
-    required: entries.filter(
-      ([, field]) => !field?.isOptional?.()
-    ).map(([key]) => key)
-  };
+	const shape = schema && "shape" in schema ? schema.shape : void 0;
+	if (typeof shape !== "object" || shape === null) return {
+		fields: [],
+		required: []
+	};
+	const entries = Object.entries(shape);
+	return {
+		fields: entries.map(([key]) => key),
+		required: entries.filter(([, field]) => !isOptionalField(field)).map(([key]) => key)
+	};
 }
-const message = (error) => error instanceof Error ? error.message : String(error);
-const issuePath = (path) => (path ?? []).map(
-  (segment) => typeof segment === "object" ? String(segment.key) : String(segment)
-).join(".");
+var isOptionalField = (field) => typeof field === "object" && field !== null && "isOptional" in field && typeof field.isOptional === "function" && Boolean(field.isOptional());
+var message = (error) => error instanceof Error ? error.message : String(error);
+var issuePath = (path) => (path ?? []).map((segment) => typeof segment === "object" ? String(segment.key) : String(segment)).join(".");
+/**
+* Maps each row, runs `transform`, then the schema, and returns one verdict
+* per row. A valid row carries the schema's output, so a coercion shows in it.
+* A transform or schema that throws makes only its own row invalid.
+*/
 async function validateCsvRows(rows, options) {
-  const { mapping, schema, transform } = options;
-  return Promise.all(
-    rows.map(async (source, index) => {
-      let row = applyCsvMapping(source, mapping);
-      if (transform) {
-        try {
-          row = transform(row, index);
-        } catch (error) {
-          return { ok: false, row, issues: [message(error)] };
-        }
-      }
-      if (!schema) return { ok: true, row };
-      let result;
-      try {
-        result = await schema["~standard"].validate(row);
-      } catch (error) {
-        return { ok: false, row, issues: [message(error)] };
-      }
-      if (!result.issues) return { ok: true, row: result.value };
-      return {
-        ok: false,
-        row,
-        issues: result.issues.map((issue) => {
-          const path = issuePath(issue.path);
-          return path === "" ? issue.message : `${path}: ${issue.message}`;
-        })
-      };
-    })
-  );
+	const { mapping, schema, transform } = options;
+	return Promise.all(rows.map(async (source, index) => {
+		let row = applyCsvMapping(source, mapping);
+		if (transform) try {
+			row = transform(row, index);
+		} catch (error) {
+			return {
+				ok: false,
+				row,
+				issues: [message(error)]
+			};
+		}
+		if (!schema) return {
+			ok: true,
+			row
+		};
+		let result;
+		try {
+			result = await schema["~standard"].validate(row);
+		} catch (error) {
+			return {
+				ok: false,
+				row,
+				issues: [message(error)]
+			};
+		}
+		if (!result.issues) return {
+			ok: true,
+			row: result.value
+		};
+		return {
+			ok: false,
+			row,
+			issues: result.issues.map((issue) => {
+				const path = issuePath(issue.path);
+				return path === "" ? issue.message : `${path}: ${issue.message}`;
+			})
+		};
+	}));
 }
-export {
-  applyCsvMapping,
-  csvSchemaFields,
-  validateCsvRows
-};
+export { applyCsvMapping, csvSchemaFields, validateCsvRows };

package/dist/data/cache-ops.d.ts

@@ -1,17 +1,18 @@
 import type { QueryClient } from "@tanstack/query-core";
 import type { Identifier } from "../resource/identifier.js";
+import type { LooseRecord, ResourceRecord } from "../resource/record.js";
 /**
  * Optimistically remove records: drop each `getOne` entry and filter the id(s)
  * out of every cached `getList`, `getManyReference` and `getInfiniteList` page
  * (decrementing `total` when known) and `getMany` entry.
  */
-export declare function removeRecordsFromCache(queryClient: QueryClient, resource: string, ids: Identifier[]): void;
+export declare function removeRecordsFromCache<TRecord extends ResourceRecord = LooseRecord>(queryClient: QueryClient, resource: string, ids: Identifier[]): void;
 /**
  * Optimistically patch records: shallow-merge `data` into each matching
  * `getOne` entry and every matching row of every cached `getList`,
  * `getManyReference`, `getInfiniteList` page and `getMany` entry.
  */
-export declare function updateRecordsInCache(queryClient: QueryClient, resource: string, ids: Identifier[], data: Record<string, unknown>): void;
+export declare function updateRecordsInCache<TRecord extends ResourceRecord = LooseRecord>(queryClient: QueryClient, resource: string, ids: Identifier[], data: Partial<NoInfer<TRecord>>): void;
 /**
  * Shallow-merge `data` into the matching rows of every cached `getList`,
  * `getManyReference` and `getInfiniteList` page, and return a `rollback` that
@@ -19,12 +20,12 @@ export declare function updateRecordsInCache(queryClient: QueryClient, resource:
  * when it is called, so another update's patch to a different row survives.
  * An entry that holds none of the ids keeps its cached object.
  */
-export declare function patchListEntries(queryClient: QueryClient, resource: string, idSet: Set<string>, data: Record<string, unknown>): () => void;
+export declare function patchListEntries<TRecord extends ResourceRecord = LooseRecord>(queryClient: QueryClient, resource: string, idSet: Set<string>, data: Partial<NoInfer<TRecord>>): () => void;
 /**
  * Shallow-merge `data` into the matching records of every cached `getMany`
  * entry (what `ReferenceField` and `ReferenceArrayField` read through).
  */
-export declare function patchManyEntries(queryClient: QueryClient, resource: string, idSet: Set<string>, data: Record<string, unknown>): void;
+export declare function patchManyEntries<TRecord extends ResourceRecord = LooseRecord>(queryClient: QueryClient, resource: string, idSet: Set<string>, data: Partial<NoInfer<TRecord>>): void;
 /**
  * Drop the matching records from every cached `getMany` entry (what
  * `ReferenceField` and `ReferenceArrayField` read through). An entry that