@ekairos/dataset 1.8.3

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./domain"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./clearDataset.tool"), exports);
+__exportStar(require("./completeDataset.tool"), exports);
+__exportStar(require("./executeCommand.tool"), exports);
+__exportStar(require("./datasetFiles"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAwB;AACxB,2CAAwB;AACxB,4CAAyB;AACzB,sDAAmC;AACnC,yDAAsC;AACtC,wDAAqC;AACrC,iDAA8B"}

package/dist/schema.d.ts

@@ -0,0 +1,62 @@
+export declare const datasetDomain: import("@ekairos/domain").DomainInstance<{
+    readonly dataset_datasets: import("@instantdb/core").EntityDef<{
+        status: import("@instantdb/core").DataAttrDef<string, false, true>;
+        createdAt: import("@instantdb/core").DataAttrDef<number, false, true>;
+        updatedAt: import("@instantdb/core").DataAttrDef<number, false, false>;
+        title: import("@instantdb/core").DataAttrDef<string, false, false>;
+        analysis: import("@instantdb/core").DataAttrDef<any, false, false>;
+        schema: import("@instantdb/core").DataAttrDef<any, false, false>;
+        calculatedTotalRows: import("@instantdb/core").DataAttrDef<number, false, false>;
+        actualGeneratedRowCount: import("@instantdb/core").DataAttrDef<number, false, false>;
+    }, {}, void>;
+    readonly dataset_records: import("@instantdb/core").EntityDef<{
+        rowContent: import("@instantdb/core").DataAttrDef<any, true, false>;
+        order: import("@instantdb/core").DataAttrDef<number, true, true>;
+        createdAt: import("@instantdb/core").DataAttrDef<number, true, false>;
+    }, {}, void>;
+    readonly $files: import("@instantdb/core").EntityDef<{
+        id: import("@instantdb/core").DataAttrDef<string, true, true>;
+        createdAt: import("@instantdb/core").DataAttrDef<number, true, true>;
+        updatedAt: import("@instantdb/core").DataAttrDef<number, false, true>;
+        name: import("@instantdb/core").DataAttrDef<string, false, false>;
+        type: import("@instantdb/core").DataAttrDef<string, false, false>;
+    }, {}, void>;
+}, {
+    readonly dataset_datasetsOrganization: {
+        readonly forward: {
+            readonly on: "dataset_datasets";
+            readonly has: "one";
+            readonly label: "organization";
+        };
+        readonly reverse: {
+            readonly on: "organizations";
+            readonly has: "many";
+            readonly label: "dataset_datasets";
+        };
+    };
+    readonly dataset_datasetsRecords: {
+        readonly forward: {
+            readonly on: "dataset_datasets";
+            readonly has: "many";
+            readonly label: "records";
+        };
+        readonly reverse: {
+            readonly on: "dataset_records";
+            readonly has: "one";
+            readonly label: "dataset";
+        };
+    };
+    readonly dataset_datasetsFiles: {
+        readonly forward: {
+            readonly on: "dataset_datasets";
+            readonly has: "one";
+            readonly label: "dataFile";
+        };
+        readonly reverse: {
+            readonly on: "$files";
+            readonly has: "many";
+            readonly label: "datasets";
+        };
+    };
+}, {}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AA6CA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAqC,CAAA"}

package/dist/schema.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datasetDomain = void 0;
+const core_1 = require("@instantdb/core");
+const domain_1 = require("@ekairos/domain");
+const entities = {
+    dataset_datasets: core_1.i.entity({
+        status: core_1.i.string().optional().indexed(),
+        createdAt: core_1.i.number().optional().indexed(),
+        updatedAt: core_1.i.number().optional(),
+        title: core_1.i.string().optional(),
+        analysis: core_1.i.json().optional(),
+        schema: core_1.i.json().optional(),
+        calculatedTotalRows: core_1.i.number().optional(),
+        actualGeneratedRowCount: core_1.i.number().optional(),
+    }),
+    dataset_records: core_1.i.entity({
+        rowContent: core_1.i.json(),
+        order: core_1.i.number().indexed(),
+        createdAt: core_1.i.number(),
+    }),
+    $files: core_1.i.entity({
+        id: core_1.i.string().indexed(),
+        createdAt: core_1.i.number().indexed(),
+        updatedAt: core_1.i.number().optional().indexed(),
+        name: core_1.i.string().optional(),
+        type: core_1.i.string().optional(),
+    }),
+};
+const links = {
+    dataset_datasetsOrganization: {
+        forward: { on: "dataset_datasets", has: "one", label: "organization" },
+        reverse: { on: "organizations", has: "many", label: "dataset_datasets" },
+    },
+    dataset_datasetsRecords: {
+        forward: { on: "dataset_datasets", has: "many", label: "records" },
+        reverse: { on: "dataset_records", has: "one", label: "dataset" },
+    },
+    dataset_datasetsFiles: {
+        forward: { on: "dataset_datasets", has: "one", label: "dataFile" },
+        reverse: { on: "$files", has: "many", label: "datasets" },
+    },
+};
+const rooms = {};
+exports.datasetDomain = (0, domain_1.domain)({ entities, links, rooms });
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":";;;AAAA,0CAAmC;AACnC,4CAAwC;AAExC,MAAM,QAAQ,GAAG;IACf,gBAAgB,EAAE,QAAC,CAAC,MAAM,CAAC;QACzB,MAAM,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE;QACvC,SAAS,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE;QAC1C,SAAS,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAChC,KAAK,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC5B,QAAQ,EAAE,QAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;QAC7B,MAAM,EAAE,QAAC,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE;QAC3B,mBAAmB,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC1C,uBAAuB,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC/C,CAAC;IACF,eAAe,EAAE,QAAC,CAAC,MAAM,CAAC;QACxB,UAAU,EAAE,QAAC,CAAC,IAAI,EAAE;QACpB,KAAK,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE;QAC3B,SAAS,EAAE,QAAC,CAAC,MAAM,EAAE;KACtB,CAAC;IACF,MAAM,EAAE,QAAC,CAAC,MAAM,CAAC;QACf,EAAE,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE;QACxB,SAAS,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE;QAC/B,SAAS,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE;QAC1C,IAAI,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC3B,IAAI,EAAE,QAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC5B,CAAC;CACM,CAAA;AAEV,MAAM,KAAK,GAAG;IACZ,4BAA4B,EAAE;QAC5B,OAAO,EAAE,EAAE,EAAE,EAAE,kBAAkB,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE;QACtE,OAAO,EAAE,EAAE,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,EAAE;KACzE;IACD,uBAAuB,EAAE;QACvB,OAAO,EAAE,EAAE,EAAE,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE;QAClE,OAAO,EAAE,EAAE,EAAE,EAAE,iBAAiB,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE;KACjE;IACD,qBAAqB,EAAE;QACrB,OAAO,EAAE,EAAE,EAAE,EAAE,kBAAkB,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE;QAClE,OAAO,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE;KAC1D;CACO,CAAA;AAEV,MAAM,KAAK,GAAG,EAAW,CAAA;AAEZ,QAAA,aAAa,GAAG,IAAA,eAAM,EAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAA"}

package/dist/service.d.ts

@@ -0,0 +1,73 @@
+export type ServiceResult<T = any> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+};
+export declare class DatasetService {
+    private readonly db;
+    constructor();
+    createDataset(params: {
+        id?: string;
+        sources?: string;
+        instructions?: string;
+        status?: string;
+        organizationId?: string;
+        [key: string]: any;
+    }): Promise<ServiceResult<{
+        datasetId: string;
+    }>>;
+    updateDataset(datasetId: string, updates: Record<string, any>): Promise<ServiceResult<void>>;
+    addDatasetRecords(params: {
+        datasetId: string;
+        records: Array<{
+            rowContent: any;
+            order: number;
+        }>;
+    }): Promise<ServiceResult<{
+        savedCount: number;
+    }>>;
+    batchAddDatasetRecords(params: {
+        datasetId: string;
+        shardMutations: any[];
+        manifestMetadata?: any;
+    }): Promise<ServiceResult<void>>;
+    findDatasetByFileId(fileId: string): Promise<any | null>;
+    findDatasetRecords(datasetId: string): Promise<any[]>;
+    getFileById(fileId: string): Promise<any>;
+    getDatasetById(datasetId: string): Promise<ServiceResult<any>>;
+    updateDatasetSchema(params: {
+        datasetId: string;
+        schema: any;
+        status?: string;
+    }): Promise<ServiceResult<void>>;
+    updateDatasetStatus(params: {
+        datasetId: string;
+        status: string;
+        calculatedTotalRows?: number;
+        actualGeneratedRowCount?: number;
+    }): Promise<ServiceResult<void>>;
+    getDatasetRecordsForDeletion(datasetId: string): Promise<ServiceResult<Array<{
+        id: string;
+    }>>>;
+    deleteDatasetRecordsBatch(recordIds: string[]): Promise<ServiceResult<number>>;
+    clearDataset(datasetId: string): Promise<ServiceResult<{
+        deletedCount: number;
+    }>>;
+    uploadDatasetOutputFile(params: {
+        datasetId: string;
+        fileBuffer: Buffer;
+    }): Promise<ServiceResult<{
+        fileId: string;
+        storagePath: string;
+    }>>;
+    linkFileToDataset(params: {
+        datasetId: string;
+        fileId: string;
+        storagePath: string;
+    }): Promise<ServiceResult<void>>;
+    readRecordsFromFile(datasetId: string): Promise<ServiceResult<AsyncGenerator<any, void, unknown>>>;
+    getContextByDatasetId(datasetId: string): Promise<ServiceResult<any>>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

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

package/dist/service.js

@@ -0,0 +1,423 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetService = void 0;
+const admin_1 = require("@instantdb/admin");
+const schema_1 = require("./schema");
+class DatasetService {
+    constructor() {
+        this.db = (0, admin_1.init)({
+            appId: process.env.NEXT_PUBLIC_INSTANT_APP_ID,
+            adminToken: process.env.INSTANT_APP_ADMIN_TOKEN,
+            schema: schema_1.datasetDomain.schema()
+        });
+    }
+    async createDataset(params) {
+        try {
+            const datasetId = params.id ?? (0, admin_1.id)();
+            const mutations = [];
+            mutations.push(this.db.tx.dataset_datasets[datasetId].update({
+                sources: params.sources ?? "",
+                instructions: params.instructions ?? "",
+                status: params.status ?? "created",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+                ...params,
+            }));
+            if (params.organizationId) {
+                mutations.push(this.db.tx.dataset_datasets[datasetId].link({
+                    organization: params.organizationId,
+                }));
+            }
+            await this.db.transact(mutations);
+            return { ok: true, data: { datasetId } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async updateDataset(datasetId, updates) {
+        try {
+            await this.db.transact([
+                this.db.tx.dataset_datasets[datasetId].update({
+                    ...updates,
+                    updatedAt: Date.now(),
+                })
+            ]);
+            return { ok: true, data: undefined };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async addDatasetRecords(params) {
+        try {
+            const mutations = [];
+            for (const record of params.records) {
+                const recordId = (0, admin_1.id)();
+                mutations.push(this.db.tx.dataset_records[recordId].update({
+                    rowContent: record.rowContent,
+                    order: record.order,
+                    createdAt: Date.now(),
+                }), this.db.tx.dataset_datasets[params.datasetId].link({ records: [recordId] }));
+            }
+            if (mutations.length > 0) {
+                await this.db.transact(mutations);
+            }
+            return { ok: true, data: { savedCount: params.records.length } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async batchAddDatasetRecords(params) {
+        try {
+            const finalMutations = [...params.shardMutations];
+            if (params.manifestMetadata) {
+                finalMutations.push(this.db.tx.dataset_datasets[params.datasetId].update({
+                    status: "completed",
+                    updatedAt: Date.now(),
+                    actualGeneratedRowCount: params.manifestMetadata.totalRowsSaved ?? 0,
+                }));
+            }
+            if (finalMutations.length > 0) {
+                await this.db.transact(finalMutations);
+            }
+            return { ok: true, data: undefined };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async findDatasetByFileId(fileId) {
+        try {
+            const lookupResult = await this.db.query({
+                dataset_datasets: {
+                    $: {
+                        where: {
+                            "files.id": fileId,
+                        },
+                        limit: 1,
+                    }
+                },
+            });
+            return lookupResult.dataset_datasets?.[0] ?? null;
+        }
+        catch (error) {
+            console.error("Error finding dataset by file ID:", error);
+            return null;
+        }
+    }
+    async findDatasetRecords(datasetId) {
+        try {
+            const datasetRecordQuery = await this.db.query({
+                dataset_records: {
+                    $: {
+                        where: {
+                            "dataset.id": datasetId,
+                        },
+                        limit: 1,
+                        fields: ["id"],
+                    },
+                },
+            });
+            return datasetRecordQuery.dataset_records ?? [];
+        }
+        catch (error) {
+            console.error("Error finding dataset records:", error);
+            return [];
+        }
+    }
+    async getFileById(fileId) {
+        try {
+            const fileQuery = await this.db.query({
+                $files: {
+                    $: {
+                        where: {
+                            id: fileId
+                        },
+                        limit: 1
+                    }
+                },
+            });
+            return fileQuery;
+        }
+        catch (error) {
+            console.error("Error getting file by ID:", error);
+            throw error;
+        }
+    }
+    async getDatasetById(datasetId) {
+        try {
+            const query = await this.db.query({
+                dataset_datasets: {
+                    $: {
+                        where: { id: datasetId },
+                        limit: 1,
+                    },
+                },
+            });
+            const dataset = query.dataset_datasets?.[0];
+            if (!dataset) {
+                return { ok: false, error: `Dataset not found with id: ${datasetId}` };
+            }
+            return { ok: true, data: dataset };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async updateDatasetSchema(params) {
+        try {
+            await this.db.transact([
+                this.db.tx.dataset_datasets[params.datasetId].update({
+                    schema: params.schema,
+                    status: params.status ?? "schema_complete",
+                    updatedAt: Date.now(),
+                })
+            ]);
+            return { ok: true, data: undefined };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async updateDatasetStatus(params) {
+        try {
+            const updates = {
+                status: params.status,
+                updatedAt: Date.now(),
+            };
+            if (params.calculatedTotalRows !== undefined) {
+                updates.calculatedTotalRows = params.calculatedTotalRows;
+            }
+            if (params.actualGeneratedRowCount !== undefined) {
+                updates.actualGeneratedRowCount = params.actualGeneratedRowCount;
+            }
+            await this.db.transact([
+                this.db.tx.dataset_datasets[params.datasetId].update(updates)
+            ]);
+            return { ok: true, data: undefined };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async getDatasetRecordsForDeletion(datasetId) {
+        try {
+            const query = await this.db.query({
+                dataset_records: {
+                    $: {
+                        where: {
+                            "dataset.id": datasetId,
+                        },
+                    },
+                },
+            });
+            const records = query.dataset_records || [];
+            return { ok: true, data: records };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async deleteDatasetRecordsBatch(recordIds) {
+        try {
+            const tx = [];
+            for (const recordId of recordIds) {
+                tx.push(this.db.tx.dataset_records[recordId].delete());
+            }
+            await this.db.transact(tx);
+            return { ok: true, data: recordIds.length };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async clearDataset(datasetId) {
+        try {
+            const recordsResult = await this.getDatasetRecordsForDeletion(datasetId);
+            if (!recordsResult.ok) {
+                return recordsResult;
+            }
+            const records = recordsResult.data;
+            const BATCH_SIZE = 200;
+            let deletedCount = 0;
+            for (let i = 0; i < records.length; i += BATCH_SIZE) {
+                const batch = records.slice(i, i + BATCH_SIZE);
+                const batchIds = batch.map((r) => r.id);
+                const deleteResult = await this.deleteDatasetRecordsBatch(batchIds);
+                if (!deleteResult.ok) {
+                    return { ok: false, error: `Failed to delete batch at index ${i}: ${deleteResult.error}` };
+                }
+                deletedCount += deleteResult.data;
+            }
+            const statusResult = await this.updateDatasetStatus({
+                datasetId,
+                status: "cleared",
+                actualGeneratedRowCount: 0,
+                calculatedTotalRows: 0,
+            });
+            if (!statusResult.ok) {
+                return statusResult;
+            }
+            return { ok: true, data: { deletedCount } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async uploadDatasetOutputFile(params) {
+        try {
+            const storagePath = `/dataset/${params.datasetId}/output.jsonl`;
+            const uploadResult = await this.db.storage.uploadFile(storagePath, params.fileBuffer, {
+                contentType: "application/x-ndjson",
+                contentDisposition: "output.jsonl",
+            });
+            if (!uploadResult?.data?.id) {
+                return { ok: false, error: "Failed to upload file to storage" };
+            }
+            const linkResult = await this.linkFileToDataset({
+                datasetId: params.datasetId,
+                fileId: uploadResult.data.id,
+                storagePath,
+            });
+            if (!linkResult.ok) {
+                return linkResult;
+            }
+            return {
+                ok: true,
+                data: {
+                    fileId: uploadResult.data.id,
+                    storagePath,
+                },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async linkFileToDataset(params) {
+        try {
+            await this.db.transact([
+                this.db.tx.dataset_datasets[params.datasetId].link({ dataFile: params.fileId }),
+            ]);
+            return { ok: true, data: undefined };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async readRecordsFromFile(datasetId) {
+        try {
+            const fileQuery = await this.db.query({
+                dataset_datasets: {
+                    $: {
+                        where: { id: datasetId },
+                        limit: 1,
+                    },
+                    dataFile: {},
+                }, // FIX TYPE ERROR
+            });
+            const datasetRecord = fileQuery.dataset_datasets?.[0];
+            const dataFile = datasetRecord?.dataFile;
+            const linkedFile = Array.isArray(dataFile) ? dataFile[0] : dataFile;
+            if (!linkedFile || !linkedFile.url) {
+                return { ok: false, error: "Dataset output file not found" };
+            }
+            async function* createGenerator(url) {
+                const response = await fetch(url);
+                if (!response.ok || !response.body) {
+                    throw new Error(`Failed to download dataset output file: ${response.status}`);
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder("utf-8");
+                let buffer = "";
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    buffer += decoder.decode(value, { stream: true });
+                    let newlineIndex = buffer.indexOf("\n");
+                    while (newlineIndex !== -1) {
+                        const line = buffer.slice(0, newlineIndex);
+                        buffer = buffer.slice(newlineIndex + 1);
+                        const trimmed = line.trim();
+                        if (trimmed.length === 0) {
+                            newlineIndex = buffer.indexOf("\n");
+                            continue;
+                        }
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(trimmed);
+                        }
+                        catch (error) {
+                            console.error("Invalid JSON line in dataset output", error);
+                            newlineIndex = buffer.indexOf("\n");
+                            continue;
+                        }
+                        if (parsed && parsed.type === "row") {
+                            yield { rowContent: parsed.data };
+                        }
+                        newlineIndex = buffer.indexOf("\n");
+                    }
+                }
+                buffer += decoder.decode();
+                const trimmed = buffer.trim();
+                if (trimmed.length > 0) {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        if (parsed && parsed.type === "row") {
+                            yield { rowContent: parsed.data };
+                        }
+                    }
+                    catch (error) {
+                        console.error("Invalid JSON line in dataset output", error);
+                    }
+                }
+            }
+            const generator = createGenerator(linkedFile.url);
+            return { ok: true, data: generator };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    async getContextByDatasetId(datasetId) {
+        try {
+            const query = await this.db.query({
+                story_contexts: {
+                    $: {
+                        where: { "content.datasetId": datasetId },
+                        limit: 1,
+                        order: { serverCreatedAt: "desc" },
+                    },
+                },
+            });
+            const context = query.story_contexts?.[0];
+            if (!context) {
+                return { ok: false, error: `Context not found for dataset: ${datasetId}` };
+            }
+            return { ok: true, data: context };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+}
+exports.DatasetService = DatasetService;
+//# sourceMappingURL=service.js.map