@flatfile/safe-api/dist/streaming/records.js

Flatfile Safe API client with streaming capabilities

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetRecordsRequest = exports.RawRecordsUpsert = exports.StreamRecordsUpdate = exports.RawRecordsRequest = exports.SimpleStreamRecordsRequest = exports.StreamRecordsRequest = exports.GetRecordCountsRequest = exports.CreateRecordsRequest = void 0;
const jsonlines_1 = __importDefault(require("jsonlines"));
const get_request_1 = require("../utils/requests/get.request");
const post_request_1 = require("../utils/requests/post.request");
const records_1 = require("@flatfile/records");
class CreateRecordsRequest extends post_request_1.PostRequest {
    constructor(sheetId, records, options) {
        super([sheetId], records, options);
        this.retry = true;
        this.path = "/v1/sheets/:sheetId/records";
    }
}
exports.CreateRecordsRequest = CreateRecordsRequest;
class GetRecordCountsRequest extends get_request_1.GetRequest {
    constructor(sheetId, opts, options) {
        super([sheetId], opts, options);
        this.path = "/v1/sheets/:sheetId/counts";
    }
    async parseBody(body) {
        if (!body) {
            throw new Error('No response body received');
        }
        return body;
    }
}
exports.GetRecordCountsRequest = GetRecordCountsRequest;
/**
 * Request class for getting full record data with metadata and configuration
 */
class StreamRecordsRequest extends get_request_1.GetRequest {
    constructor(opts = {}, options) {
        super([], { ...opts, stream: true }, options);
        this.path = "/v2-alpha/records.jsonl";
        this.isRaw = true;
        this._headers = { Accept: "application/jsonl" };
    }
    async parseBody(body) {
        const lines = await parseJsonLines(body);
        return lines.map((r) => new records_1.FlatfileRecord(r));
    }
}
exports.StreamRecordsRequest = StreamRecordsRequest;
/**
 * Request class for getting simplified record data without internal metadata
 */
class SimpleStreamRecordsRequest extends get_request_1.GetRequest {
    constructor(opts = {}, options) {
        super([], { ...opts, stream: true }, options);
        this.path = "/v2-alpha/records.jsonl";
        this.isRaw = true;
        this._headers = { Accept: "application/jsonl" };
    }
    async parseBody(body) {
        if (typeof body === 'string') {
            const lines = await parseJsonLines(body);
            return lines.map((r) => Object.fromEntries(Object.entries(r)
                .map(([k, v]) => [k === "__k" ? "id" : k === "__m" ? "metadata" : k, v])
                .filter(([k]) => !k.startsWith("__"))));
        }
        return [];
    }
}
exports.SimpleStreamRecordsRequest = SimpleStreamRecordsRequest;
/**
 * Request class for getting raw JSONL record data
 */
class RawRecordsRequest extends get_request_1.GetRequest {
    constructor(opts = {}, options) {
        super([], { ...opts, stream: true }, options);
        this.path = "/v2-alpha/records.jsonl";
        this.isRaw = true;
        this._headers = { Accept: "application/jsonl" };
        this.query = { ...opts, stream: true };
    }
    async parseBody(body) {
        if (!body) {
            return [];
        }
        return parseJsonLines(body.toString());
    }
}
exports.RawRecordsRequest = RawRecordsRequest;
/**
 * Request class for updating records using JSONL format
 */
class StreamRecordsUpdate extends post_request_1.PostRequest {
    constructor(opts, payload, options) {
        super([], payload, options);
        this.opts = opts;
        this.path = "/v2-alpha/records.jsonl";
        this.isRaw = true;
        this._headers = { "Content-Type": "application/jsonl" };
        this.query = { ...opts, stream: true };
    }
    afterSuccess() {
        const payload = this.payload;
        payload.changes().each((r) => r.commit());
    }
    async parseBody(_body) {
        return { success: true };
    }
    serializeBody(records) {
        if (this.opts.truncate) {
            return (records
                .onlyPresent()
                .map((r) => JSON.stringify(r.toJSON()))
                .join("\n") + "\n");
        }
        else {
            const updates = records
                // removes any temporary records that have been deleted
                .filter((r) => { var _a; return !(((_a = r.id) === null || _a === void 0 ? void 0 : _a.startsWith("TEMP_")) && r.isDeleted()); })
                .changes()
                .map((r) => JSON.stringify(r.changeset()));
            if (!updates.count()) {
                throw new Error("No changes made to this collection that would need to be written.");
            }
            else {
                return updates.join("\n") + "\n";
            }
        }
    }
}
exports.StreamRecordsUpdate = StreamRecordsUpdate;
class RawRecordsUpsert extends post_request_1.PostRequest {
    constructor(opts, payload, options) {
        super([], payload, options);
        this.opts = opts;
        this.path = "/v2-alpha/records.jsonl";
        this.isRaw = true;
        this._headers = { "Content-Type": "application/jsonl", "Content-Encoding": "gzip" };
        this.query = { ...opts, stream: true };
    }
    async parseBody(_body) {
        return { success: true };
    }
    serializeBody(records) {
        return records.map((r) => JSON.stringify(r)).join("\n") + "\n";
    }
}
exports.RawRecordsUpsert = RawRecordsUpsert;
class GetRecordsRequest extends get_request_1.GetRequest {
    constructor(sheetId, query, options) {
        super([sheetId], query, options);
        this.path = "/v1/sheets/:sheetId/records";
    }
}
exports.GetRecordsRequest = GetRecordsRequest;
function parseJsonLines(body) {
    return new Promise((resolve, reject) => {
        const parser = jsonlines_1.default.parse();
        const out = [];
        parser.on("data", (data) => {
            out.push(data);
        });
        parser.on("end", () => {
            resolve(out);
        });
        parser.on("error", (err) => {
            console.error(err);
            reject(err);
        });
        parser.write(body);
        parser.end();
    });
}