airbyte-faros-destination 0.0.1

package/lib/common/graphql-client.js

@@ -0,0 +1,712 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLClient = exports.toPostgresArrayLiteral = exports.toLevels = exports.groupByKeys = exports.batchIterator = exports.mergeByPrimaryKey = exports.strictPick = exports.serialize = exports.UpsertBuffer = void 0;
+const date_format_1 = __importDefault(require("date-format"));
+const json_to_graphql_query_1 = require("json-to-graphql-query");
+const lodash_1 = require("lodash");
+const traverse_1 = __importDefault(require("traverse"));
+const ts_essentials_1 = require("ts-essentials");
+const verror_1 = require("verror");
+const types_1 = require("./types");
+const ROOT_FLAG = '__root__';
+class UpsertBuffer {
+    constructor() {
+        this.upsertBuffer = new Map();
+    }
+    add(upsert) {
+        const modelBuffer = this.upsertBuffer.get(upsert.model);
+        if (!modelBuffer) {
+            this.upsertBuffer.set(upsert.model, [upsert]);
+            return;
+        }
+        modelBuffer.push(upsert);
+    }
+    size() {
+        // the limiting factor is size of a single request
+        return Array.from(this.upsertBuffer.values()).reduce((acc, arr) => (0, lodash_1.max)([acc, arr.length]), 0);
+    }
+    pop(model) {
+        return this.getInternal(model, true);
+    }
+    get(model) {
+        return this.getInternal(model, false);
+    }
+    getInternal(model, remove) {
+        if (this.upsertBuffer.has(model)) {
+            const modelUpserts = this.upsertBuffer.get(model);
+            if (remove) {
+                this.upsertBuffer.delete(model);
+            }
+            return modelUpserts;
+        }
+        return undefined;
+    }
+    clear() {
+        const size = this.size();
+        this.upsertBuffer.clear();
+        return size;
+    }
+}
+exports.UpsertBuffer = UpsertBuffer;
+function serialize(obj) {
+    return (0, lodash_1.keys)(obj)
+        .sort()
+        .map((k) => `${k}:${obj[k]}`)
+        .join('|');
+}
+exports.serialize = serialize;
+/**
+ * Like lodash pick but with null value replacement.
+ */
+function strictPick(obj, keys, nullValue = 'null') {
+    return keys.reduce((result, key) => { var _a; return (0, lodash_1.set)(result, key, (_a = obj[key]) !== null && _a !== void 0 ? _a : nullValue); }, {});
+}
+exports.strictPick = strictPick;
+/**
+ * Groups objects by primary key and then merges all related objects into
+ * a single object where last-wins for overlapping properties.
+ */
+function mergeByPrimaryKey(objects, primaryKeys) {
+    const byPK = (0, lodash_1.groupBy)(objects, (o) => serialize((0, lodash_1.pick)(o, primaryKeys)));
+    return Object.values(byPK).map((arr) => arr.reduce((acc, obj) => ({ ...acc, ...obj }), {}));
+}
+exports.mergeByPrimaryKey = mergeByPrimaryKey;
+/**
+ * Execute async callback for each batch of upserts.
+ */
+function batchIterator(batches, callback) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            for (const batch of batches) {
+                yield await callback(batch);
+            }
+        },
+    };
+}
+exports.batchIterator = batchIterator;
+/**
+ * Separates objects into arrays of objects
+ * that all have the same keys.
+ */
+function groupByKeys(objects) {
+    const byObjKeyNames = (0, lodash_1.groupBy)(objects, (obj) => Object.keys(obj).sort().join('|'));
+    return Object.values(byObjKeyNames);
+}
+exports.groupByKeys = groupByKeys;
+/**
+ * Separates upserts into levels. Level 0 has no dependencies on other levels.
+ * Level 1 depends on Level 0, 2 on 1 and so on.
+ */
+function toLevels(upserts) {
+    const withLevel = (0, lodash_1.flatMap)(upserts, (u) => addLevel(u));
+    const byLevel = (0, lodash_1.groupBy)(withLevel, (tuple) => tuple[1]);
+    const result = [];
+    Object.keys(byLevel)
+        .sort()
+        .forEach((level) => {
+        result.push((0, lodash_1.unzip)(byLevel[level])[0]);
+    });
+    return result;
+}
+exports.toLevels = toLevels;
+/**
+ * Converts an Upsert (which is a tree structure) into an array of tuples.
+ * Each tuple contains an Upsert and its level in the tree structure.
+ * The level indicates the number of steps from a leaf where leaves are level 0.
+ * If an Upsert has multiple paths to a leaf, the level is the maximum number of
+ * steps.
+ */
+function addLevel(u) {
+    const result = [];
+    let maxAncestorLevel = 0;
+    for (const ancestor of Object.values(u.foreignKeys)) {
+        if (ancestor.model === u.model) {
+            const ancestorsWithLevels = addLevel(ancestor);
+            maxAncestorLevel = (0, lodash_1.max)([ancestorsWithLevels[0][1], maxAncestorLevel]);
+            result.push(...ancestorsWithLevels);
+        }
+    }
+    const thisLevel = result.length ? maxAncestorLevel + 1 : 0;
+    result.unshift([u, thisLevel]);
+    return result;
+}
+function toPostgresArrayLiteral(value) {
+    return `{${value
+        .map((s) => {
+        if (typeof s === 'string') {
+            return `"${s}"`;
+        }
+        if ((0, lodash_1.isNil)(s)) {
+            return 'NULL';
+        }
+        return s;
+    })
+        .join(',')}}`;
+}
+exports.toPostgresArrayLiteral = toPostgresArrayLiteral;
+/**
+ * Client for writing records as GraphQL mutations.  The client supports 3
+ * kinds of writes: Upserts, Updates and Deletes.
+ *
+ * For upserts (when upsertBatchSize is greater than 0), the high-level algorithm is:
+ *
+ * > For each record, build a tree of Upserts. The tree has more than one node if the current record represents a
+ *   nested entity (e.g. branch record referencing repo which, in-turn, references org).
+ * > Buffer Upserts and index each by model (e.g. vcs_Branch)
+ * > When batch size limit is reached, execute a single insert mutation per model. Start with leaves of Upsert tree.
+ * > After inserting a batch, copy the id of each record back to the Upsert object. When inserting subsequent batches,
+ *   required foreign keys will be read from the Upsert tree and copied to the appropriate batch mutation.
+ *
+ * Note: there is a complication in this algorithm for self-referent models (i.e. org_Employee's manager relationship).
+ * For these models, we split the batch into "levels". The first level consists of records with no dependencies on
+ * records of the same type. The second depends on the first and so on.
+ *
+ * For Updates and Deletes (which are much less frequent) we have a separate write buffer.  This buffer is
+ * flushed if it reaches capacity.  There is no attempt to combine these into bulk mutations (as done w/ upserts).
+ */
+class GraphQLClient {
+    constructor(logger, schemaLoader, backend, upsertBatchSize, mutationBatchSize, updateResetLimit = true) {
+        this.writeBuffer = [];
+        this.upsertBuffer = new UpsertBuffer();
+        this.selfReferentModels = new Set();
+        this.logger = logger;
+        this.schemaLoader = schemaLoader;
+        this.backend = backend;
+        this.upsertBatchSize = upsertBatchSize !== null && upsertBatchSize !== void 0 ? upsertBatchSize : 10000;
+        this.mutationBatchSize = mutationBatchSize !== null && mutationBatchSize !== void 0 ? mutationBatchSize : 100;
+        (0, ts_essentials_1.assert)(this.upsertBatchSize >= 0, `negative upsert batch size: ${this.upsertBatchSize}`);
+        (0, ts_essentials_1.assert)(this.mutationBatchSize > 0, `non-positive mutation batch size: ${this.mutationBatchSize}`);
+        this.updateResetLimit = updateResetLimit;
+        this.resetLimitMillis = updateResetLimit
+            ? // January 1, 2200
+                7258118400000
+            : Date.now();
+    }
+    async healthCheck() {
+        try {
+            await this.backend.healthCheck();
+        }
+        catch (e) {
+            throw new verror_1.VError(e, 'Failed to check graphql backend health');
+        }
+    }
+    async loadSchema() {
+        this.schema = await this.schemaLoader.loadSchema();
+        // various derivative values of schema
+        this.tableNames = new Set(this.schema.tableNames);
+        this.tableDependencies = [...this.schema.sortedModelDependencies];
+        (0, lodash_1.reverse)(this.tableDependencies);
+        // self-referent models
+        for (const [model, modelRefs] of Object.entries(this.schema.references)) {
+            for (const reference of Object.values(modelRefs)) {
+                if (reference.model === model) {
+                    this.selfReferentModels.add(model);
+                }
+            }
+        }
+    }
+    checkSchema() {
+        if (!this.schema) {
+            throw new verror_1.VError('Schema is not initialized. Please call loadSchema first.');
+        }
+    }
+    async resetData(origin, models, keepReferencedRecords) {
+        this.checkSchema();
+        // ensure deletes are executed after processing records
+        await this.flush();
+        const minRefreshedAt = new Date(this.resetLimitMillis).toISOString();
+        this.logger.info(`Resetting data before ${minRefreshedAt} for origin ${origin}`);
+        for (const model of (0, lodash_1.intersection)(this.schema.sortedModelDependencies, models)) {
+            this.logger.info(`Resetting ${model} data for origin ${origin}`);
+            const deleteConditions = {
+                origin: { _eq: origin },
+                refreshedAt: { _lt: minRefreshedAt },
+            };
+            if (keepReferencedRecords) {
+                deleteConditions['_not'] = {
+                    _or: this.schema.backReferences[model].map((br) => {
+                        return {
+                            [br.field]: {},
+                        };
+                    }),
+                };
+            }
+            const mutation = {
+                [`delete_${model}`]: {
+                    __args: {
+                        where: {
+                            _and: { ...deleteConditions },
+                        },
+                    },
+                    affected_rows: true,
+                },
+            };
+            await this.postQuery({ mutation }, `Failed to reset ${model} data for origin ${origin}`);
+        }
+    }
+    async writeRecord(model, record, origin) {
+        this.checkSchema();
+        if (!this.tableNames.has(model)) {
+            throw new verror_1.VError(`Table ${model} does not exist`);
+        }
+        if (this.upsertBatchSize) {
+            this.addUpsert(model, record, origin);
+            if (this.upsertBuffer.size() >= this.upsertBatchSize) {
+                await this.flushUpsertBuffer();
+            }
+        }
+        else {
+            const obj = this.createMutationObject(model, record, origin);
+            const mutation = {
+                [`insert_${model}_one`]: { __args: obj, id: true, refreshedAt: true },
+            };
+            await this.postQuery({ mutation }, `Failed to write ${model} record`);
+        }
+    }
+    async flushUpsertBuffer() {
+        try {
+            await this.doFlushUpsertBuffer();
+        }
+        catch (e) {
+            const numRemoved = this.upsertBuffer.clear();
+            throw new verror_1.VError(e, 'failed to flush upsert buffer. abandoned %d records', numRemoved);
+        }
+    }
+    async execUpsert(model, op) {
+        // write batch
+        const opGql = (0, json_to_graphql_query_1.jsonToGraphQLQuery)(op.query);
+        const start = Date.now();
+        const opRes = await this.backend.postQuery(opGql);
+        const end = Date.now();
+        // extract ids of newly written records and set on upserts.
+        // the ids are used as foreign keys by subsequent batches
+        // step 1: access array of results
+        // will be at path 'opRes.data.insert_<model>.returning'
+        const paths = (0, lodash_1.keys)(opRes.data);
+        (0, ts_essentials_1.assert)(paths.length === 1, `expected one element in ${paths}`);
+        const objects = (0, lodash_1.get)(opRes.data, `${paths[0]}.returning`);
+        (0, ts_essentials_1.assert)(Array.isArray(objects), `expected array`);
+        for (const obj of objects) {
+            // step 2: assign id to all upserts related to this object
+            // construct key from returned result and lookup upsert by key
+            const key = this.serializedPrimaryKey(model, obj);
+            const upserts = op.upsertsByKey.get(key);
+            (0, ts_essentials_1.assert)(upserts, `failed to resolve upserts for ${model} and ${key}`);
+            (0, ts_essentials_1.assert)(obj.id, `failed to resolve id for ${model} and ${JSON.stringify(obj)}`);
+            upserts.forEach((u) => (u.id = obj.id));
+            if (this.updateResetLimit && op.isRoot) {
+                const recordRefreshedAtMs = new Date(obj.refreshedAt).getTime();
+                this.resetLimitMillis = Math.min(recordRefreshedAtMs, this.resetLimitMillis);
+            }
+        }
+        return {
+            model,
+            numObjects: objects.length,
+            durationMs: end - start,
+        };
+    }
+    async doFlushUpsertBuffer() {
+        for (const model of this.tableDependencies) {
+            const modelUpserts = this.upsertBuffer.pop(model);
+            if (modelUpserts) {
+                const withLevels = this.selfReferentModels.has(model)
+                    ? toLevels(modelUpserts)
+                    : [modelUpserts];
+                const iterator = batchIterator(withLevels, (batch) => {
+                    const ops = this.toUpsertOps(model, batch);
+                    return Promise.all(ops.map((op) => this.execUpsert(model, op)));
+                });
+                try {
+                    for await (const results of iterator) {
+                        for (const result of results) {
+                            this.logger.debug(`Executed ${model} upsert with ${result.numObjects} object(s) in ${result.durationMs}ms`);
+                        }
+                    }
+                }
+                catch (e) {
+                    throw new verror_1.VError(e, `failed to write upserts for ${model}`);
+                }
+            }
+        }
+    }
+    async writeTimestampedRecord(record) {
+        switch (record.operation) {
+            case types_1.Operation.UPSERT:
+                await this.writeRecord(record.model, record.data, record.origin);
+                break;
+            case types_1.Operation.UPDATE:
+                await this.writeUpdateRecord(record);
+                break;
+            case types_1.Operation.DELETION:
+                await this.writeDeletionRecord(record);
+                break;
+            default:
+                throw new verror_1.VError(`Unsupported operation ${record.operation} for ${record}`);
+        }
+    }
+    async writeUpdateRecord(record) {
+        const upsertRec = {
+            ...record.where,
+            ...(0, lodash_1.pick)(record.patch, record.mask),
+        };
+        const obj = this.createMutationObject(record.model, upsertRec, record.origin, true);
+        const mutation = {
+            [`insert_${record.model}_one`]: { __args: obj, id: true },
+        };
+        await this.postQuery({ mutation }, `Failed to update ${record.model} record`);
+    }
+    async writeDeletionRecord(record) {
+        const mutation = {
+            [`delete_${record.model}`]: {
+                __args: {
+                    where: this.createWhereClause(record.model, record.where),
+                },
+                affected_rows: true,
+            },
+        };
+        await this.postQuery({ mutation }, `Failed to delete ${record.model} record`);
+    }
+    async postQuery(query, errorMsg) {
+        this.writeBuffer.push({
+            query,
+            errorMsg,
+        });
+        if (this.writeBuffer.length >= this.mutationBatchSize) {
+            await this.flush();
+        }
+    }
+    async flush() {
+        // sequentially flush upsert then write buffer
+        // we do this sequentially because we may have updates
+        // that operate on records in the upsert buffers and
+        // therefore need the upserts written first
+        await this.flushUpsertBuffer();
+        await this.flushWriteBuffer();
+    }
+    async flushWriteBuffer() {
+        const queries = this.writeBuffer.map((op) => op.query);
+        const gql = GraphQLClient.batchMutation(queries);
+        if (gql) {
+            const res = await this.backend.postQuery(gql);
+            if (res.errors) {
+                this.logger.warn(`Error while saving batch: ${JSON.stringify(res.errors)}. Query: ${gql}`);
+                // now try mutations individually and fail on the first bad one
+                for (const op of this.writeBuffer) {
+                    const opGql = (0, json_to_graphql_query_1.jsonToGraphQLQuery)(op.query);
+                    const opRes = await this.backend.postQuery(opGql);
+                    this.writeBuffer.shift();
+                    if (opRes.errors) {
+                        throw new verror_1.VError(`${op.errorMsg} with query '${opGql}': ${JSON.stringify(opRes.errors)}`);
+                    }
+                }
+            }
+            else {
+                // res.data is expected to have one object with 'id' and 'refreshedAt' for each of the mutations
+                // {
+                //   "m0": {
+                //     "id": ...,
+                //     "refreshedAt": ...
+                //   },
+                //   "m1": {
+                //     "id": ...,
+                //     "refreshedAt": ...
+                //   },
+                //   ...
+                // }
+                if (this.updateResetLimit) {
+                    for (const mutationRes of Object.values(res.data)) {
+                        const refreshedAt = (0, lodash_1.get)(mutationRes, 'refreshedAt');
+                        if (refreshedAt) {
+                            const recordRefreshedAtMs = new Date(refreshedAt).getTime();
+                            this.resetLimitMillis = Math.min(recordRefreshedAtMs, this.resetLimitMillis);
+                        }
+                    }
+                }
+                // truncate the buffer
+                this.writeBuffer.splice(0);
+            }
+        }
+    }
+    /**
+     * Constructs a gql query from an array of json mutations.
+     * The outputted qql mutation might look like:
+     *
+     *   mutation  {
+     *     i1: insert_cicd_Artifact_one(object: {uid: "u1b"}) {
+     *       id
+     *       refreshedAt
+     *     }
+     *     i2: insert_cicd_Artifact_one(object: {uid: "u2b"}) {
+     *       id
+     *       refreshedAt
+     *     }
+     *   }
+     *
+     *  Notable here are the i1/i2 aliases.  These are required when multiple operations
+     *  share the same name (e.g. insert_cicd_Artifact_one) and are supported in
+     *  jsonToGraphQLQuery with __aliasFor directive.
+     *
+     *  @return batch gql mutation or undefined if the input is undefined, empty
+     *  or doesn't contain any mutations.
+     */
+    static batchMutation(queries) {
+        if (queries && queries.length > 0) {
+            const queryObj = {};
+            queries.forEach((query, idx) => {
+                if (query.mutation) {
+                    const queryType = Object.keys(query.mutation)[0];
+                    const queryBody = query.mutation[queryType];
+                    queryObj[`m${idx}`] = {
+                        __aliasFor: queryType,
+                        ...queryBody,
+                    };
+                }
+            });
+            if (Object.keys(queryObj).length > 0) {
+                return (0, json_to_graphql_query_1.jsonToGraphQLQuery)({ mutation: queryObj });
+            }
+        }
+        return undefined;
+    }
+    createWhereClause(model, record) {
+        const obj = {};
+        for (const [field, value] of Object.entries(record)) {
+            const nestedModel = this.schema.references[model][field];
+            if (nestedModel && value) {
+                obj[nestedModel.field] = this.createWhereClause(nestedModel.model, value);
+            }
+            else {
+                const val = this.formatFieldValue(model, field, value);
+                if (val)
+                    obj[field] = { _eq: val };
+            }
+        }
+        return obj;
+    }
+    createMutationObject(model, record, origin, keepExistingOrigin, nested) {
+        const obj = {};
+        const foreignKeys = [];
+        for (const [field, value] of Object.entries(record)) {
+            const nestedModel = this.schema.references[model][field];
+            if (nestedModel && value) {
+                foreignKeys.push(nestedModel.foreignKey);
+                obj[nestedModel.field] = this.createMutationObject(nestedModel.model, value, undefined, keepExistingOrigin, true);
+            }
+            else {
+                const val = this.formatFieldValue(model, field, value);
+                if (!(0, lodash_1.isNil)(val))
+                    obj[field] = val;
+            }
+        }
+        if (origin) {
+            obj['origin'] = origin;
+        }
+        const updateFieldMask = new Set(Object.keys(obj).concat(foreignKeys));
+        if (keepExistingOrigin) {
+            updateFieldMask.delete('origin');
+        }
+        return {
+            [nested ? 'data' : 'object']: obj,
+            on_conflict: this.createConflictClause(model, nested, updateFieldMask),
+        };
+    }
+    addUpsert(model, record, origin) {
+        const object = {};
+        const foreignKeys = {};
+        for (const [field, value] of Object.entries(record)) {
+            const nestedModel = this.schema.references[model][field];
+            if (nestedModel) {
+                if ((0, lodash_1.isNil)(value)) {
+                    // for explicit nil relation, set the FK of this record to null
+                    object[nestedModel.foreignKey] = null;
+                }
+                else {
+                    foreignKeys[field] = this.addUpsert(nestedModel.model, value);
+                }
+            }
+            else if (this.isValidField(model, field)) {
+                const val = this.formatFieldValue(model, field, value);
+                object[field] = (0, lodash_1.isNil)(val) ? null : val;
+            }
+        }
+        if (origin) {
+            object['origin'] = origin;
+            // add root flag to top-level objects
+            object[ROOT_FLAG] = true;
+        }
+        // since all our uids are non-null, check for nil uids early
+        // to prevent losing an entire batch later with db constraint
+        // error on flush
+        if ((0, lodash_1.has)(object, 'uid') && (0, lodash_1.isNil)(object['uid'])) {
+            throw new verror_1.VError('cannot upsert null or undefined uid for model %s with keys %s', model, JSON.stringify((0, lodash_1.pick)(record, this.schema.primaryKeys[model])));
+        }
+        const upsert = {
+            model,
+            object,
+            foreignKeys: foreignKeys,
+        };
+        // index by model
+        this.upsertBuffer.add(upsert);
+        return upsert;
+    }
+    objectWithForeignKeys(upsert) {
+        if ((0, lodash_1.isEmpty)(upsert.foreignKeys)) {
+            return upsert.object;
+        }
+        // for each FK, copy id of related upsert to FK field
+        // the upsert's id was populated after the associated batch
+        // was written in doFlushUpsertBuffer
+        const result = (0, lodash_1.clone)(upsert.object);
+        for (const [relName, fkUpsert] of Object.entries(upsert.foreignKeys)) {
+            // foreign key was constructed from schema so the following is safe to access
+            const fkField = this.schema.references[upsert.model][relName].foreignKey;
+            const fkValue = fkUpsert.id;
+            (0, ts_essentials_1.assert)(!(0, lodash_1.isNil)(fkValue), `failed to resolve fk value for ${relName} from ${JSON.stringify(fkUpsert)}`);
+            result[fkField] = fkValue;
+        }
+        return result;
+    }
+    /**
+     * returns serialized version of keys fields
+     */
+    serializedPrimaryKey(model, obj) {
+        return serialize(strictPick(obj, this.schema.primaryKeys[model]));
+    }
+    toUpsertOps(model, modelUpserts) {
+        // shared among all the results of this method
+        const upsertsByKey = new Map();
+        // add FKs and index upsert by primary key
+        // the index is needed after write to find source
+        // upsert and set id
+        const all = modelUpserts.map((u) => {
+            const fullObj = this.objectWithForeignKeys(u);
+            const key = this.serializedPrimaryKey(model, fullObj);
+            const upsertsForKey = upsertsByKey.get(key);
+            if (!upsertsForKey) {
+                upsertsByKey.set(key, [u]);
+            }
+            else {
+                upsertsForKey.push(u);
+            }
+            return fullObj;
+        });
+        const primaryKeys = this.schema.primaryKeys[model];
+        // there can be multiple records that represent the
+        // same object.  merge all records into one
+        const allObjects = mergeByPrimaryKey(all, primaryKeys);
+        const keysObj = primaryKeys
+            .sort()
+            .reduce((a, v) => ({ ...a, [v]: true }), {});
+        // for each set of unique keys, build an UpsertOp
+        const groups = groupByKeys(allObjects);
+        return groups.map((objects) => {
+            (0, ts_essentials_1.assert)(objects === null || objects === void 0 ? void 0 : objects.length, 'objects should not be empty');
+            // all objects have same fields due to groupByKeys call
+            // pull out fields of first as mask for update fields to ensure
+            // fields that aren't in the data are not modified by the upsert
+            const updateColumnMask = new Set(Object.keys(objects[0]));
+            // determine if this group contains root objects
+            let isRoot = false;
+            if ((0, lodash_1.has)(objects[0], ROOT_FLAG)) {
+                isRoot = true;
+                // remove root flag from all objects
+                objects.forEach((o) => delete o[ROOT_FLAG]);
+            }
+            const onConflict = this.createUpsertConflictClause(model, updateColumnMask, isRoot);
+            const mutation = {
+                mutation: {
+                    [`insert_${model}`]: {
+                        __args: {
+                            // sort objects to avoid deadlocks on concurrent inserts
+                            objects: (0, lodash_1.orderBy)(objects, primaryKeys),
+                            on_conflict: onConflict,
+                        },
+                        returning: {
+                            id: true,
+                            refreshedAt: true,
+                            ...keysObj,
+                        },
+                    },
+                },
+            };
+            return {
+                query: mutation,
+                upsertsByKey,
+                isRoot,
+            };
+        });
+    }
+    isValidField(model, field) {
+        return (0, lodash_1.has)(this.schema.scalars[model], field);
+    }
+    formatFieldValue(model, field, value) {
+        if ((0, lodash_1.isNil)(value))
+            return undefined;
+        if (!this.isValidField(model, field)) {
+            this.logger.debug(`Could not find type of ${field} in ${model}`);
+            return undefined;
+        }
+        const type = this.schema.scalars[model][field];
+        if (type === 'timestamptz') {
+            // The field value may already be a string. E.g., if coming from the Faros Feeds source.
+            return typeof value === 'string' ? value : timestamptz(value);
+        }
+        else if (type.startsWith('_') && typeof value !== 'string') {
+            if (!Array.isArray(value)) {
+                throw new Error(`expected array for ${model}.${field} of type ${type}. Received: ${JSON.stringify(value)}`);
+            }
+            // format array value as postgres literal
+            return toPostgresArrayLiteral(value);
+        }
+        else if (typeof value === 'object' || Array.isArray(value)) {
+            return (0, traverse_1.default)(value).map(function (val) {
+                if (val instanceof Date) {
+                    this.update(val.getTime());
+                }
+            });
+        }
+        return value;
+    }
+    createConflictClause(model, nested, updateFieldMask) {
+        const updateColumns = nested
+            ? []
+            : (0, lodash_1.difference)(Object.keys(this.schema.scalars[model]), this.schema.primaryKeys[model]);
+        const filteredUpdateFields = updateFieldMask && !nested
+            ? updateColumns.filter((c) => updateFieldMask.has(c))
+            : updateColumns;
+        // if empty, use model keys to ensure queries always return results
+        if ((0, lodash_1.isEmpty)(filteredUpdateFields)) {
+            filteredUpdateFields.push(...this.schema.primaryKeys[model]);
+        }
+        return {
+            constraint: new json_to_graphql_query_1.EnumType(`${model}_pkey`),
+            update_columns: filteredUpdateFields.map((c) => new json_to_graphql_query_1.EnumType(c)),
+        };
+    }
+    createUpsertConflictClause(model, updateFieldMask, isRoot) {
+        // superset of fields that can be updated
+        const updateColumns = (0, lodash_1.difference)(Object.keys(this.schema.scalars[model]), this.schema.primaryKeys[model]);
+        // filter to only those fields that are in the data
+        const filteredUpdateFields = updateColumns.filter((c) => updateFieldMask.has(c));
+        // for root objects, always update refreshedAt
+        if (isRoot) {
+            filteredUpdateFields.push('refreshedAt');
+        }
+        // if empty, use model keys to ensure queries always return results
+        if ((0, lodash_1.isEmpty)(filteredUpdateFields)) {
+            filteredUpdateFields.push(...this.schema.primaryKeys[model]);
+        }
+        return {
+            constraint: new json_to_graphql_query_1.EnumType(`${model}_pkey`),
+            update_columns: filteredUpdateFields.map((c) => new json_to_graphql_query_1.EnumType(c)),
+        };
+    }
+}
+exports.GraphQLClient = GraphQLClient;
+function timestamptz(date) {
+    return date_format_1.default.asString(date_format_1.default.ISO8601_WITH_TZ_OFFSET_FORMAT, date);
+}
+//# sourceMappingURL=graphql-client.js.map