@rebasepro/admin 0.13.1-canary.gef9608c → 0.14.0

package/dist/data_export/export/fetch_export_data.d.ts

@@ -0,0 +1,48 @@
+import { Entity, FindParams, FindResponse } from "@rebasepro/types";
+/**
+ * Rows asked for per request.
+ *
+ * Kept at or below the server's `MAX_LIST_LIMIT`, which is now the largest page
+ * a read will serve *and refuses* anything larger — it used to clamp silently,
+ * and asking for 100 000 while receiving 1 000 looked exactly like a collection
+ * with 1 000 rows in it. The walk still never trusts the page size it asked for:
+ * it advances by the rows it was actually handed.
+ */
+export declare const EXPORT_PAGE_SIZE = 500;
+/**
+ * Most rows one browser-side export will materialise.
+ *
+ * Everything here is built in memory and handed to a Blob, so there is a
+ * ceiling whether or not it is named. Naming it means going over it **throws**
+ * instead of writing a short file that reads like the whole collection.
+ */
+export declare const MAX_EXPORT_ROWS = 100000;
+export interface FetchAllForExportParams<M extends Record<string, unknown>> {
+    /** The collection accessor to read through — `dataClient.collection(path)`. */
+    accessor: {
+        find(params?: FindParams<M>): Promise<FindResponse<M>>;
+    };
+    /** Query to export. The window (`limit` / `offset` / `page`) is owned by the walk. */
+    params?: Omit<FindParams<M>, "limit" | "offset" | "page">;
+    pageSize?: number;
+    maxRows?: number;
+    /** Called after every page with the rows so far, and the total when the server reports one. */
+    onProgress?: (loaded: number, total: number | undefined) => void;
+}
+/**
+ * Read **every** row matching a query, one page at a time.
+ *
+ * `find({})` sends no `limit`, and an absent limit is resolved server-side to
+ * `DEFAULT_LIST_LIMIT` — 50 rows. The export used to hand those 50 rows back as
+ * `<collection>.csv` with nothing saying it was a sample, next to a dialog
+ * warning that the collection had 100 000 documents.
+ *
+ * Termination is driven by the server's `meta.hasMore` where it is reported and
+ * by an empty page otherwise — never by comparing a page's length against the
+ * requested limit, since a final page that happens to be exactly full is
+ * indistinguishable that way and a walk that stops there drops rows.
+ *
+ * @throws When more than `maxRows` rows match. A truncated export is worse than
+ * no export: it is indistinguishable from a complete one.
+ */
+export declare function fetchAllEntitiesForExport<M extends Record<string, unknown>>({ accessor, params, pageSize, maxRows, onProgress }: FetchAllForExportParams<M>): Promise<Entity<M>[]>;

package/dist/data_export/export/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./export";
+export * from "./fetch_export_data";
 export * from "./BasicExportAction";
 export * from "./ExportCollectionAction";

package/dist/data_import/utils/csv.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Split CSV text into rows of raw cells, RFC 4180 style.
+ *
+ * Quoted fields may contain the delimiter, newlines and doubled quotes; this is
+ * the exact inverse of what the export's `entryToCSVRow` writes, so a file this
+ * admin produced reads back into the cells it was built from.
+ */
+export declare function parseCsvRows(text: string, delimiter?: string): string[][];
+/**
+ * Pick the delimiter that splits the header row into the most cells. A
+ * single-column file matches nothing and stays on the comma.
+ */
+export declare function detectCsvDelimiter(text: string): string;
+export interface ParsedCsv {
+    headers: string[];
+    data: Record<string, string>[];
+}
+/**
+ * Parse CSV text into one object per row, keyed by the header row.
+ *
+ * The picker accepts `.csv` and the dialog promises "Upload a CSV, Excel or JSON
+ * file", but every non-JSON file used to be handed to ExcelJS'
+ * `workbook.xlsx.load`, which is a zip reader — so every CSV failed with
+ * "Can't find end of central directory : is this a zip file ?". The export
+ * writes CSV by default, so the round trip could not close.
+ *
+ * A blank header keeps its column rather than collapsing it, so the cells to its
+ * right stay under their own names.
+ */
+export declare function parseCsvToObjects(text: string): ParsedCsv;

package/dist/data_import/utils/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./file_to_json";
+export * from "./csv";
+export * from "./save_entities";
 export * from "./data";
 export * from "./get_import_inference_type";

package/dist/data_import/utils/save_entities.d.ts

@@ -0,0 +1,38 @@
+import { Entity, RebaseData } from "@rebasepro/types";
+/** Rows written per request, and per transaction where the data source has one. */
+export declare const IMPORT_BATCH_SIZE = 25;
+/**
+ * An import failure that says where it stopped.
+ *
+ * "Error saving data / null value in column "sku" violates not-null constraint"
+ * on a ten-thousand-row import named no row, and the Retry button restarted at
+ * zero — where the rows already written now conflicted, so it could never
+ * succeed. Both halves of that are what this carries.
+ */
+export interface ImportSaveError extends Error {
+    /** Rows written and confirmed before the failure. Where a retry resumes. */
+    committed: number;
+    /** Index of the first row that was not written, 0-based. */
+    failedFrom: number;
+    /** Index after the last row of the batch that was not written. */
+    failedTo: number;
+}
+/**
+ * Write imported entities in batches, reporting what was committed.
+ *
+ * Resumable on purpose: a failure at row 4 000 leaves rows 1–3 999 in the table
+ * whatever this does, so the only useful thing to report is where to carry on
+ * from. `offset` is that point — the Retry button passes back the `committed`
+ * count of the error it is retrying, instead of starting from zero and
+ * conflicting on every row that already exists.
+ *
+ * @throws {ImportSaveError} naming the rows that were not written.
+ */
+export declare function saveImportedEntities(dataClient: RebaseData, path: string, data: Partial<Entity<any>>[], { offset, batchSize, onBatchCommitted, bulkUnsupported }?: {
+    offset?: number;
+    batchSize?: number;
+    onBatchCommitted?: (rowsWritten: number) => void;
+    bulkUnsupported?: {
+        current: boolean;
+    };
+}): Promise<void>;

package/dist/data_import/utils/transforms.d.ts

@@ -1,6 +1,15 @@
 /**
  * Take an object with keys of type `address.street`, `address.city` and
  * convert it to an object with nested objects like `{ address: { street: ..., city: ... } }`
+ *
+ * Keys here are the **header row of an uploaded file**, so they are attacker
+ * data. `res["__proto__"] = …` is the prototype setter rather than an own
+ * property, so a column named `__proto__.polluted` walked out of the accumulator
+ * and wrote onto `Object.prototype` for the life of the tab — and
+ * `constructor.prototype.x` threw a `TypeError` that surfaced as an unreadable
+ * file. Such a column is refused, not sanitised, the way `setIn` settled it
+ * (`docs/bug-classes.md` class 22).
+ *
  * @param flatObj
  */
 export declare function unflattenObject(flatObj: {

package/dist/editor.js

@@ -948,6 +948,7 @@ var ImageBubble = forwardRef(({ options, className }, ref) => {
 		},
 		children: [/* @__PURE__ */ jsx(TextField, {
 			size: "small",
+			"aria-label": t("alt_text"),
 			placeholder: t("alt_text"),
 			value: alt,
 			onChange: (e) => {
@@ -956,6 +957,7 @@ var ImageBubble = forwardRef(({ options, className }, ref) => {
 			}
 		}), /* @__PURE__ */ jsx(TextField, {
 			size: "small",
+			"aria-label": t("title"),
 			placeholder: t("title"),
 			value: title,
 			onChange: (e) => {
@@ -1614,6 +1616,7 @@ var LinkSelector = ({ open, onOpenChange }) => {
 			children: [/* @__PURE__ */ jsx(TextField, {
 				inputRef,
 				autoFocus: open,
+				"aria-label": t("editor_paste_or_type_link"),
 				placeholder: t("editor_paste_or_type_link"),
 				defaultValue: href,
 				size: "small",