@t4h.framework/fs 0.5.0 → 0.7.0

package/README.md

@@ -1,6 +1,10 @@
 # @t4h.framework/fs
 
-File system claim for reading and writing files within activities.
+File system claim for reading and writing files within activities, plus the
+workflow-facing file activities: `split` fans a large file out into one child
+workflow per slice, `join` folds the batch results back into a single file,
+and `read` brings a small byte window (a header, a trailer) into the workflow
+as a string.
 
 ## Claim
 
@@ -16,8 +20,17 @@ import { FileSystemClaim } from '@t4h.framework/fs'
 
 ```typescript
 abstract class FileSystemClaim {
-  public abstract write(path: string, readable: Readable | Buffer): Binary | Promise<Binary>
+  public abstract write(
+    path: string,
+    readable: Readable | Buffer,
+  ): Binary | Promise<Binary>
   public abstract read(path: string): Binary | Promise<Binary>
+
+  public abstract slice(
+    binary: Binary,
+    range: { start: number; end: number },
+    encoding?: BufferEncoding,
+  ): Binary | Promise<Binary>
 }
 ```
 
@@ -27,7 +40,11 @@ abstract class FileSystemClaim {
 import { SyncActivity, Claim } from '@t4h.framework/core'
 import { FileSystemClaim } from '@t4h.framework/fs'
 
-class SaveReportActivity extends SyncActivity<[data: Buffer], { path: string }, any> {
+class SaveReportActivity extends SyncActivity<
+  [data: Buffer],
+  { path: string },
+  any
+> {
   private readonly claims = new Claim({
     fs: FileSystemClaim,
   })
@@ -54,3 +71,280 @@ The runtime must supply a concrete implementation:
 ```typescript
 { provide: FileSystemClaim, value: new LocalFileSystemClaimImpl() }
 ```
+
+## File read
+
+### read
+
+Reads a byte window of a `Binary` into the workflow as a decoded string. The
+output is recorded in the workflow history (replay never re-reads the file),
+which is why reads are capped at 1 MiB: this is the primitive for headers,
+trailers and single records — a data file flows through `split`, never through
+`read`.
+
+```typescript
+import { read } from '@t4h.framework/fs'
+
+const header = await read(file, { range: { start: 0, end: 240 } })
+
+const trailer = await read(file, {
+  range: { start: file.contentLength - 240, end: file.contentLength },
+})
+```
+
+Options: `range` (default: the whole binary, subject to the same cap) and
+`encoding` (default `'utf8'`).
+
+The activity tries `FileSystemClaim.slice` first — on a file-backed binary a
+trailer read is a ranged download, whatever the file size. Binaries the claim
+cannot slice (e.g. an SFTP reference) fall back to streaming: the stream is
+consumed up to the window and destroyed as soon as it is filled, so a header
+read pulls the first chunks only, whatever the file size. The one expensive
+case is a trailing window over a non-sliceable binary — the stream must
+traverse the whole file to reach it.
+
+Reading a slice is relative to the slice: `read(slice, { range: { start: 0,
+end: 10 } })` returns the first 10 bytes of the slice, not of the underlying
+file — slice ranges compose.
+
+## File split
+
+### split
+
+Splits a file into byte-range slices, starts one child workflow per slice as
+a single batch, and suspends the parent until every child is terminal —
+regardless of each child succeeding or failing (a rejected child never
+rejects the batch):
+
+```typescript
+import { split, Split } from '@t4h.framework/fs'
+
+const processRecord = new Workflow(
+  { id: 'process-record', schema: Type.String() },
+  async (record: string) => {
+    // record is the raw slice content
+  },
+)
+
+const main = new Workflow(fileSchema, async (file: Binary) => {
+  const batch = await split(file, processRecord, {
+    delimiter: Split.line(),
+  })
+
+  // this line only runs once the whole batch is terminal;
+  // batch: WorkflowBatchRef — { id: string, count: number }
+})
+```
+
+The design goal is constant memory regardless of file size:
+
+1. The source stream is read **exactly once**, worker side. The same pass
+   persists a durable copy through `FileSystemClaim.write` while a byte
+   scanner records the slice offsets — no slice content is ever materialized
+   in the activity.
+2. Children receive **range views** over the durable copy
+   (`FileSystemClaim.slice`).
+3. The activity output is just the batch reference (`{ id, count }`), so the
+   parent history stays O(1) whatever the slice count. Per-child results are
+   never aggregated: they live with each child run, to be inspected
+   individually through the batch id.
+
+Child workflows declare their real input type (e.g. `Type.String()`); how the
+bytes reach them is a runtime concern.
+
+### Delimiters
+
+The cut is defined by the dev through a serializable delimiter spec. When the
+delimiter is found at `[p, p + length)`, the previous slice ends at
+`p + keep.previous` and the next slice starts at `p + length - keep.next`; the
+bytes in between are discarded. The defaults discard the whole delimiter
+(classic line semantics).
+
+```typescript
+Split.line() // cut at every '\n', delimiter discarded
+Split.char(';') // cut at any byte sequence
+Split.char(';', { previous: 1 }) // keep the ';' with the previous slice
+Split.char('\n10', { next: 2 }) // positional files, see below
+```
+
+The last form targets positional files where a logical record spans multiple
+physical lines and a new record only starts when a line begins with a marker
+(the record type code):
+
+```
+10JOHN;123\n20detail-a\n20detail-b\n10MARY;456\n20detail-c
+└──────────── record 1 ───────────┘└─────── record 2 ──────┘
+```
+
+With `Split.char('\n10', { next: 2 })` the newline between records is
+discarded, and the `10` marker — which is data, not separator — stays at the
+start of the next slice.
+
+### Options
+
+```typescript
+await split(file, workflow, {
+  delimiter: Split.line(), // required: where to cut
+  every: 10_000, // cut only every N occurrences (groups records)
+  trim: { start: 241, end: 241 }, // bytes cut off each end before scanning
+  skipEmpty: false, // keep zero-length slices (default: skipped)
+  encoding: 'latin1', // delimiter bytes + slice hydration (default: utf8)
+  timeoutInMs: 3_600_000, // max ms to await the batch; rejects on expiry
+})
+```
+
+- **`every`** groups N records per child. With one million lines, `every:
+10_000` starts 100 children instead of one million; each child receives a
+  raw block with its inner delimiters untouched and iterates locally. `keep`
+  arithmetic only applies at actual cut points.
+- **`trim`** cuts a fixed number of bytes off each end of the file before
+  scanning — a positional header/trailer, which may not be aligned with the
+  record delimiter (a record-start delimiter like `Split.char('\n10')` fuses
+  the trailer into the last record's slice, so counting records would drop a
+  valid one along with it). Trimmed content never becomes a slice nor counts
+  toward `every`; fetch it with `read`. Getting the byte counts right is the
+  caller's business — positional layouts make them constants:
+
+  ```typescript
+  const header = await read(file, { range: { start: 0, end: 240 } })
+
+  const batch = await split(file, processInvoice, {
+    delimiter: Split.char('\n10', { next: 2 }),
+    trim: { start: 241, end: 241 }, // header + '\n', trailer + '\n'
+  })
+  ```
+
+- **`skipEmpty`** (default `true`) drops zero-length slices — consecutive
+  delimiters, or a file starting/ending with one — so they never become child
+  workflows. Turn it off when the slice index must align 1:1 with the record
+  position in the source file. "Empty" means zero bytes: a whitespace-only
+  line is a regular slice.
+- **`encoding`** converts the delimiter to bytes and tells the runtime how to
+  hydrate each slice for the child. Offsets are always computed over raw
+  bytes, so multi-byte encodings never skew the ranges.
+- **`timeoutInMs`** is the maximum time in milliseconds to await the batch. On
+  expiry the activity rejects (reason `timeout`) instead of suspending
+  forever — the safety net for a child that never reaches a terminal state.
+
+## File join
+
+The inverse of `split`: folds the results of a completed batch into a single
+file. Outputs stream in one at a time through `WorkflowBatchClaim` and flow
+straight into `FileSystemClaim.write` with backpressure, so memory stays
+bounded whatever the batch size — only the resulting binary reaches the
+workflow history.
+
+```typescript
+import { join, split, Split } from '@t4h.framework/fs'
+
+const batch = await split(file, processRecord, { delimiter: Split.line() })
+
+const csv = await join(batch, {
+  format: 'csv',
+  columns: [
+    { key: 'id', header: 'Código' },
+    { key: 'value', header: 'Valor (R$)' },
+    'date', // shorthand: key === header
+  ],
+})
+// csv: Binary
+```
+
+### Formats
+
+- **`lines`** — concatenates raw child outputs; the child owns the line
+  format. Options: `header`, `separator` (default `'\n'`).
+- **`entries`** — NDJSON dump of `{ index, status, output }`, one entry per
+  line. The format-agnostic view of the batch, rejected children included by
+  default.
+- **`csv`** — projects object outputs into RFC 4180 escaped columns. Options:
+  `columns` (required; each entry is `{ key, header? }` where `key` selects
+  the value on the child output — a dot-path like `'meta.total'` reaches
+  nested fields, matching the `where` semantics; a literal top-level key that
+  contains dots wins over the nested path — and `header` is the label on the
+  header row — a plain string is shorthand for `{ key }`), `delimiter`
+  (default `','`), `header` (default `true`; emits the column labels as the
+  first row).
+
+### Status filter
+
+`status` selects which child results make it into the file, instead of an
+error policy: it defaults to `['fulfilled']` for `lines` and `csv`, and to
+both statuses for `entries`. Filtering is silent by design — a file of
+rejected children for reprocessing is one call away:
+
+```typescript
+const failures = await join(batch, { format: 'entries', status: ['rejected'] })
+```
+
+### Where filter
+
+`where` narrows results with a [sift](https://github.com/crcn/sift.js)
+(MongoDB-style) query over each entry's output, applied after the `status`
+filter. The accepted subset is deliberate — only declarative, JSON-only
+operators: `$eq`, `$ne`, `$lt`, `$lte`, `$gt`, `$gte`, `$in`, `$nin`,
+`$exists`, `$not`, `$and`, `$or`, `$nor`, plus plain equality and dot-paths
+for nested fields:
+
+```typescript
+const relevant = await join(batch, {
+  format: 'csv',
+  columns: ['id', 'total'],
+  where: {
+    valid: true, // plain strict equality
+    total: { $gt: 100 }, // operators
+    'meta.situacao': 'aprovada', // dot-path into nested output
+    $or: [{ ref: 'a' }, { ref: 'b' }],
+  },
+})
+```
+
+`join` also accepts the child output type as a generic — top-level keys then
+narrow to its fields, with values typed by the field (dot-paths are accepted
+without narrowing):
+
+```typescript
+type InvoiceResult = { id: string; valid: boolean; total: number }
+
+await join<InvoiceResult>(batch, {
+  format: 'csv',
+  columns: ['id'],
+  where: { valid: true, total: { $gt: 100 } }, // { valid: 'yes' } rejects
+})
+```
+
+Anything that cannot serialize losslessly into the workflow history is
+rejected eagerly at `toInput` with a `TypeError`: functions (including
+`$where`), `RegExp` values (including `$regex`), `undefined`, and operators
+outside the subset — a dropped closure would make the replay filter
+differently than the first execution. For arbitrary predicates, write a
+custom activity in project code (the function then lives in versioned code,
+not in history).
+
+Two MongoDB semantics worth knowing: array fields match by containment
+(`{ tags: 'a' }` matches `tags: ['a', 'b']`), and equality against an object
+value compares deeply (never by reference). Comparisons never coerce types.
+
+Filtering runs inside the existing streaming loop, over outputs that are
+already hydrated one at a time — the query compiles once and adds one
+predicate call per entry, no extra serialization and no change to the memory
+profile. It is applied app-side: every child output is still fetched and
+parsed; `where` decides what enters the file, not what leaves the database.
+
+### ByteDelimiterScanner
+
+The scanner behind `split` is exported for direct use. It is a pass-through
+`Transform`: chunks flow through unchanged (so the same pass can persist the
+file) while it records slice offsets in absolute byte positions, handling
+delimiters split across chunk boundaries. `ranges` is complete once the stream
+has flushed.
+
+```typescript
+import { ByteDelimiterScanner } from '@t4h.framework/fs'
+
+const scanner = new ByteDelimiterScanner({ delimiter: { value: '\n' } })
+
+await pipeline(source, scanner, destination)
+
+scanner.ranges // [{ start: 0, end: 3 }, ...]
+```

package/dist/FileSystemClaim.d.ts

@@ -3,5 +3,9 @@ import type { Binary } from '@t4h.framework/core';
 export declare abstract class FileSystemClaim {
     abstract write(path: string, readable: Readable | Buffer): Binary | Promise<Binary>;
     abstract read(path: string): Binary | Promise<Binary>;
+    abstract slice(binary: Binary, range: {
+        start: number;
+        end: number;
+    }, encoding?: BufferEncoding): Binary | Promise<Binary>;
 }
 //# sourceMappingURL=FileSystemClaim.d.ts.map

package/dist/FileSystemClaim.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileSystemClaim.d.ts","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,8BAAsB,eAAe;aACnB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAC1B,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAEX,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAC7D"}
+{"version":3,"file":"FileSystemClaim.d.ts","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,8BAAsB,eAAe;aACnB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAC1B,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAEX,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;aAE5C,KAAK,CACnB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EACrC,QAAQ,CAAC,EAAE,cAAc,GACxB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAC5B"}

package/dist/FileSystemClaim.js.map

@@ -1 +1 @@
-{"version":3,"file":"FileSystemClaim.js","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAIA,MAAM,OAAgB,eAAe;CAOpC"}
+{"version":3,"file":"FileSystemClaim.js","sourceRoot":"","sources":["../src/FileSystemClaim.ts"],"names":[],"mappings":"AAIA,MAAM,OAAgB,eAAe;CAapC"}

package/dist/activities/FileJoinActivity.d.ts

@@ -0,0 +1,59 @@
+import { type Binary, type Serializable, SyncActivity, type WorkflowBatchRef } from '@t4h.framework/core';
+import { CSV } from '../helpers/CSV.js';
+export type FileJoinStatus = 'fulfilled' | 'rejected';
+type FileJoinWhereOperators<TValue> = {
+    $eq?: TValue;
+    $ne?: TValue;
+    $lt?: TValue;
+    $lte?: TValue;
+    $gt?: TValue;
+    $gte?: TValue;
+    $in?: TValue[];
+    $nin?: TValue[];
+    $exists?: boolean;
+    $not?: FileJoinWhereCondition<TValue>;
+};
+type FileJoinWhereCondition<TValue> = TValue | FileJoinWhereOperators<TValue>;
+export type FileJoinWhere<TOutput = unknown> = ([TOutput] extends [object] ? {
+    [K in keyof TOutput]?: FileJoinWhereCondition<Exclude<TOutput[K], undefined>>;
+} & {
+    [path: `${string}.${string}`]: Serializable;
+} : Record<string, Serializable>) & {
+    $and?: FileJoinWhere<TOutput>[];
+    $or?: FileJoinWhere<TOutput>[];
+    $nor?: FileJoinWhere<TOutput>[];
+};
+type FileJoinOptionsBase<TOutput> = {
+    status?: FileJoinStatus[];
+    where?: FileJoinWhere<TOutput>;
+};
+type FileJoinOptionsLines<TOutput> = FileJoinOptionsBase<TOutput> & {
+    format: 'lines';
+    header?: string;
+    separator?: string;
+};
+type FileJoinOptionsEntries<TOutput> = FileJoinOptionsBase<TOutput> & {
+    format: 'entries';
+};
+type FileJoinOptionsCsv<TOutput> = FileJoinOptionsBase<TOutput> & {
+    format: 'csv';
+    columns: CSV.Column[];
+    delimiter?: string;
+    header?: boolean;
+};
+export type FileJoinOptions<TOutput = unknown> = FileJoinOptionsLines<TOutput> | FileJoinOptionsEntries<TOutput> | FileJoinOptionsCsv<TOutput>;
+export type FileJoinActivityInput = {
+    batch: string;
+    options: FileJoinOptions;
+};
+export declare class FileJoinActivity extends SyncActivity<readonly [batch: WorkflowBatchRef, options: FileJoinOptions], FileJoinActivityInput, Binary, Binary> {
+    private readonly claims;
+    toInput(batch: WorkflowBatchRef, options: FileJoinOptions): FileJoinActivityInput;
+    run({ batch, options }: FileJoinActivityInput): Promise<Binary>;
+    toOutput(output: Binary): Binary;
+    private writeHeader;
+    private toLine;
+}
+export declare function join<TOutput = unknown>(batch: WorkflowBatchRef, options: FileJoinOptions<TOutput>): Promise<Binary>;
+export {};
+//# sourceMappingURL=FileJoinActivity.d.ts.map

package/dist/activities/FileJoinActivity.d.ts.map

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

package/dist/activities/FileJoinActivity.js

@@ -0,0 +1,74 @@
+import { once } from 'node:events';
+import { PassThrough } from 'node:stream';
+import { Claim, History, SyncActivity, WorkflowBatchClaim, } from '@t4h.framework/core';
+import sift from 'sift';
+import { OPERATIONS } from '../constants/operations.js';
+import { FileSystemClaim } from '../FileSystemClaim.js';
+import { CSV } from '../helpers/CSV.js';
+import { assertWhereSerializable } from '../tools/assert-where-serializable.js';
+const extensions = {
+    lines: 'txt',
+    entries: 'ndjson',
+    csv: 'csv',
+};
+export class FileJoinActivity extends SyncActivity {
+    claims = new Claim({
+        fs: FileSystemClaim,
+        batch: WorkflowBatchClaim,
+    });
+    toInput(batch, options) {
+        if (options.where)
+            assertWhereSerializable(options.where, 'where');
+        return { batch: batch.id, options };
+    }
+    async run({ batch, options }) {
+        const stream = new PassThrough();
+        const writing = this.claims.fs.write(`join/${this.id}.${extensions[options.format]}`, stream);
+        const write = async (line) => {
+            if (!stream.write(line))
+                await once(stream, 'drain');
+        };
+        const statuses = new Set(options.status ?? ['fulfilled']);
+        if (!options.status && options.format === 'entries')
+            statuses.add('rejected');
+        const matches = options.where &&
+            sift.createQueryTester(options.where, {
+                operations: OPERATIONS,
+            });
+        await this.writeHeader(options, write);
+        for await (const entry of this.claims.batch.outputs(batch)) {
+            if (!statuses.has(entry.status))
+                continue;
+            if (matches && !matches(entry.output))
+                continue;
+            await write(this.toLine(entry, options));
+        }
+        stream.end();
+        return await writing;
+    }
+    toOutput(output) {
+        return output;
+    }
+    async writeHeader(options, write) {
+        if (options.format === 'lines' && options.header)
+            await write(options.header + (options.separator ?? '\n'));
+        if (options.format === 'csv' && options.header !== false)
+            await write(CSV.toHeader(options.columns, { delimiter: options.delimiter }));
+    }
+    toLine(entry, options) {
+        if (options.format === 'entries')
+            return JSON.stringify(entry) + '\n';
+        if (options.format === 'csv')
+            return CSV.toLine(entry.output, options.columns, {
+                delimiter: options.delimiter,
+            });
+        const value = typeof entry.output === 'string'
+            ? entry.output
+            : JSON.stringify(entry.output);
+        return value + (options.separator ?? '\n');
+    }
+}
+export async function join(batch, options) {
+    return await History.reconciler(FileJoinActivity, batch, options);
+}
+//# sourceMappingURL=FileJoinActivity.js.map

package/dist/activities/FileJoinActivity.js.map

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

package/dist/activities/FileReadActivity.d.ts

@@ -0,0 +1,22 @@
+import { type Binary, SyncActivity } from '@t4h.framework/core';
+export type FileReadOptions = {
+    range?: {
+        start: number;
+        end: number;
+    };
+    encoding?: BufferEncoding;
+};
+export type FileReadActivityInput = {
+    binary: Binary;
+    options: FileReadOptions;
+};
+export declare class FileReadActivity extends SyncActivity<readonly [binary: Binary, options: FileReadOptions], FileReadActivityInput, string, string> {
+    private readonly claims;
+    toInput(binary: Binary, options: FileReadOptions): FileReadActivityInput;
+    run({ binary, options, }: FileReadActivityInput): Promise<string>;
+    toOutput(output: string): string;
+    private slice;
+    private window;
+}
+export declare function read(binary: Binary, options?: FileReadOptions): Promise<string>;
+//# sourceMappingURL=FileReadActivity.d.ts.map

package/dist/activities/FileReadActivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileReadActivity.d.ts","sourceRoot":"","sources":["../../src/activities/FileReadActivity.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,MAAM,EAAkB,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAI/E,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACtC,QAAQ,CAAC,EAAE,cAAc,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA;AAID,qBAAa,gBAAiB,SAAQ,YAAY,CAChD,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,CAAC,EACnD,qBAAqB,EACrB,MAAM,EACN,MAAM,CACP;IACC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAErB;IAEK,OAAO,CACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,GACvB,qBAAqB;IAIX,GAAG,CAAC,EACf,MAAM,EACN,OAAO,GACR,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC;IAyBnC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;YAIzB,KAAK;YAYL,MAAM;CAuCrB;AAED,wBAAsB,IAAI,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,MAAM,CAAC,CAEjB"}

package/dist/activities/FileReadActivity.js

@@ -0,0 +1,68 @@
+import { buffer } from 'node:stream/consumers';
+import { Claim, History, SyncActivity } from '@t4h.framework/core';
+import { FileSystemClaim } from '../FileSystemClaim.js';
+const FILE_READ_MAX_BYTES = 1024 * 1024;
+export class FileReadActivity extends SyncActivity {
+    claims = new Claim({
+        fs: FileSystemClaim,
+    });
+    toInput(binary, options) {
+        return { binary, options };
+    }
+    async run({ binary, options, }) {
+        const encoding = options.encoding ?? 'utf8';
+        const range = options.range ?? { start: 0, end: binary.contentLength };
+        const length = range.end - range.start;
+        if (!Number.isInteger(range.start) || range.start < 0 || length < 0)
+            throw new TypeError('Read range must be a non-negative byte window');
+        if (range.end > binary.contentLength)
+            throw new TypeError('Read range must not exceed the binary length');
+        if (length > FILE_READ_MAX_BYTES)
+            throw new RangeError(`Length ${length} exceeded max ${FILE_READ_MAX_BYTES}`);
+        const slice = await this.slice(binary, range, encoding);
+        if (slice)
+            return (await buffer(await slice.stream())).toString(encoding);
+        return (await this.window(await binary.stream(), range)).toString(encoding);
+    }
+    toOutput(output) {
+        return output;
+    }
+    async slice(binary, range, encoding) {
+        try {
+            return await this.claims.fs.slice(binary, range, encoding);
+        }
+        catch {
+            return null;
+        }
+    }
+    async window(readable, range) {
+        const chunks = [];
+        let position = 0;
+        let size = 0;
+        try {
+            for await (const data of readable) {
+                const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                const chunkStart = position;
+                position += chunk.length;
+                if (position <= range.start)
+                    continue;
+                const from = Math.max(range.start - chunkStart, 0);
+                const to = Math.min(range.end - chunkStart, chunk.length);
+                chunks.push(chunk.subarray(from, to));
+                size += to - from;
+                if (position >= range.end)
+                    break;
+            }
+        }
+        finally {
+            readable.destroy();
+        }
+        if (size < range.end - range.start)
+            throw new RangeError('Binary stream ended before the read window was filled');
+        return Buffer.concat(chunks);
+    }
+}
+export async function read(binary, options = {}) {
+    return await History.reconciler(FileReadActivity, binary, options);
+}
+//# sourceMappingURL=FileReadActivity.js.map

package/dist/activities/FileReadActivity.js.map

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

package/dist/activities/FileSplitActivity.d.ts

@@ -1,36 +1,39 @@
-import { AsyncActivityAwaitable, type Binary, StartWorkflowActivity, SyncActivity, Workflow } from '@t4h.framework/core';
-import type Type from 'typebox';
-import { type ParserFormat } from '../helpers/parsers.js';
-export type FileSplitOptionsBase<TFormat extends ParserFormat> = {
-    format: TFormat;
+import { AsyncActivity, type Binary, type Workflow, WorkflowBatchRef, workflowBatchSchema } from '@t4h.framework/core';
+import { type ByteTrim, type FileSplitDelimiter } from '../helpers/byte-delimiter-scanner.js';
+export type FileSplitOptions = {
+    delimiter: FileSplitDelimiter;
+    every?: number;
+    trim?: ByteTrim;
+    skipEmpty?: boolean;
     encoding?: BufferEncoding;
+    timeoutInMs?: number;
 };
-type FileSplitOptionsLine = FileSplitOptionsBase<'txt' | 'ndjson'> & {
-    trimEnd?: boolean;
-};
-type FileSplitOptionsCSV = FileSplitOptionsBase<'csv'> & {
-    delimiter?: string;
-};
-type FileSplitOptionsCustom = FileSplitOptionsBase<string> & {
-    delimiter?: string;
-    trimEnd?: boolean;
-};
-type FileSplitOptions = FileSplitOptionsLine | FileSplitOptionsCSV | FileSplitOptionsCustom;
 export type FileSplitActivityInput = {
     binary: Binary;
-    options?: FileSplitOptions;
+    workflow: string;
+    options: FileSplitOptions;
 };
-export declare class FileSplitActivity extends SyncActivity<readonly [binary: Binary, options?: FileSplitOptions], FileSplitActivityInput, Binary[], Binary[]> {
+export type FileSplitBatch = {
+    batch: string;
+    count: number;
+};
+export declare class FileSplitActivity extends AsyncActivity<readonly [
+    binary: Binary,
+    workflow: Workflow<any, any>,
+    options: FileSplitOptions
+], FileSplitActivityInput, FileSplitBatch, WorkflowBatchRef, FileSplitActivityInput, typeof workflowBatchSchema> {
     private readonly claims;
-    toInput(binary: Binary, options?: FileSplitOptions): FileSplitActivityInput;
-    run({ binary, options, }: FileSplitActivityInput): Promise<Binary[]>;
-    toOutput(binaries: Binary[]): Binary[];
+    toInput(binary: Binary, workflow: Workflow<any, any>, options: FileSplitOptions): FileSplitActivityInput;
+    bootstrap({ binary, workflow, options, }: FileSplitActivityInput): Promise<import("@t4h.framework/core").AsyncActivityResultPending<FileSplitActivityInput, import("typebox").TObject<{
+        batch: import("typebox").TString;
+        count: import("typebox").TNumber;
+    }>> | import("@t4h.framework/core").AsyncActivityResultFulfilled<FileSplitBatch | undefined>>;
+    advance(payload: FileSplitBatch): import("@t4h.framework/core").AsyncActivityResultFulfilled<FileSplitBatch | undefined>;
+    toOutput(output: FileSplitBatch): WorkflowBatchRef;
+}
+export declare function split(binary: Binary, workflow: Workflow<any, any>, options: FileSplitOptions): Promise<WorkflowBatchRef>;
+export declare namespace Split {
+    const line: (value?: string) => FileSplitDelimiter;
+    const char: (value: string, keep?: FileSplitDelimiter["keep"]) => FileSplitDelimiter;
 }
-type BinaryWorkflow = Workflow<Type.TObject<{
-    binary: Type.TSchema;
-}>, any>;
-export declare function split(binary: Binary, workflow: BinaryWorkflow, options?: FileSplitOptions & {
-    parallel?: boolean;
-}): Promise<AsyncActivityAwaitable<StartWorkflowActivity>[]>;
-export {};
 //# sourceMappingURL=FileSplitActivity.d.ts.map