@memberjunction/server 5.27.1 → 5.28.0

package/dist/resolvers/IntegrationDiscoveryResolver.js

@@ -12,9 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 var IntegrationDiscoveryResolver_1;
 import { Resolver, Query, Mutation, Arg, Ctx, ObjectType, Field, InputType } from "type-graphql";
-import { CompositeKey, Metadata, RunView, LogError } from "@memberjunction/core";
+import { CompositeKey, LocalCacheManager, Metadata, RunView, LogError } from "@memberjunction/core";
 import { CronExpressionHelper } from "@memberjunction/scheduling-engine";
-import { ConnectorFactory, IntegrationEngine } from "@memberjunction/integration-engine";
+import { ConnectorFactory, IntegrationEngine, IntegrationSchemaSync } from "@memberjunction/integration-engine";
 import { SchemaBuilder, TypeMapper, SchemaEvolution } from "@memberjunction/integration-schema-builder";
 import { RuntimeSchemaManager } from "@memberjunction/schema-engine";
 import { ResolverBase } from "../generic/ResolverBase.js";
@@ -135,6 +135,10 @@ __decorate([
     Field({ nullable: true, defaultValue: 'created', description: 'Sync scope: "created" = only newly created entity maps, "all" = all maps for the connector' }),
     __metadata("design:type", String)
 ], ApplyAllInput.prototype, "SyncScope", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 'Pull', description: 'SyncDirection applied to all created entity maps: Pull | Push | Bidirectional. Defaults to Pull.' }),
+    __metadata("design:type", String)
+], ApplyAllInput.prototype, "DefaultSyncDirection", void 0);
 ApplyAllInput = __decorate([
     InputType()
 ], ApplyAllInput);
@@ -269,6 +273,10 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", String)
 ], ApplyAllBatchConnectorInput.prototype, "ScheduleTimezone", void 0);
+__decorate([
+    Field({ nullable: true, defaultValue: 'Pull', description: 'SyncDirection applied to all created entity maps for this connector: Pull | Push | Bidirectional. Defaults to Pull.' }),
+    __metadata("design:type", String)
+], ApplyAllBatchConnectorInput.prototype, "DefaultSyncDirection", void 0);
 ApplyAllBatchConnectorInput = __decorate([
     InputType()
 ], ApplyAllBatchConnectorInput);
@@ -290,6 +298,14 @@ __decorate([
     Field({ nullable: true, defaultValue: 'created', description: 'Sync scope: "created" = only newly created entity maps, "all" = all maps for the connector' }),
     __metadata("design:type", String)
 ], ApplyAllBatchInput.prototype, "SyncScope", void 0);
+__decorate([
+    Field({ nullable: true, description: 'Override sync direction for the initial sync: Pull | Push | Bidirectional. Defaults to entity map SyncDirection.' }),
+    __metadata("design:type", String)
+], ApplyAllBatchInput.prototype, "SyncDirection", void 0);
+__decorate([
+    Field({ nullable: true, description: 'Override sync direction stored in the created schedule: Pull | Push | Bidirectional.' }),
+    __metadata("design:type", String)
+], ApplyAllBatchInput.prototype, "ScheduleSyncDirection", void 0);
 ApplyAllBatchInput = __decorate([
     InputType()
 ], ApplyAllBatchInput);
@@ -997,6 +1013,27 @@ __decorate([
 StartSyncOutput = __decorate([
     ObjectType()
 ], StartSyncOutput);
+let WriteRecordOutput = class WriteRecordOutput {
+};
+__decorate([
+    Field(),
+    __metadata("design:type", Boolean)
+], WriteRecordOutput.prototype, "Success", void 0);
+__decorate([
+    Field(),
+    __metadata("design:type", String)
+], WriteRecordOutput.prototype, "Message", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], WriteRecordOutput.prototype, "ExternalID", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Number)
+], WriteRecordOutput.prototype, "StatusCode", void 0);
+WriteRecordOutput = __decorate([
+    ObjectType()
+], WriteRecordOutput);
 let CreateScheduleInput = class CreateScheduleInput {
 };
 __decorate([
@@ -1019,6 +1056,14 @@ __decorate([
     Field({ nullable: true }),
     __metadata("design:type", String)
 ], CreateScheduleInput.prototype, "Description", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", String)
+], CreateScheduleInput.prototype, "SyncDirection", void 0);
+__decorate([
+    Field({ nullable: true }),
+    __metadata("design:type", Boolean)
+], CreateScheduleInput.prototype, "FullSync", void 0);
 CreateScheduleInput = __decorate([
     InputType()
 ], CreateScheduleInput);
@@ -1713,14 +1758,21 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
         // DB entities may not have Description populated yet on first run,
         // but the connector's GetIntegrationObjects() always has them.
         const connectorDescriptions = this.buildDescriptionLookup(connector);
-        return objects.map(obj => {
+        const results = [];
+        for (const obj of objects) {
             const sourceObj = sourceSchema.Objects.find(o => o.ExternalName.toLowerCase() === obj.SourceObjectName.toLowerCase());
             const objDescriptions = connectorDescriptions.get(obj.SourceObjectName.toLowerCase());
+            // If the object wasn't discovered in IntrospectSchema (e.g. API error), skip it
+            // rather than generating a broken table with no columns and a fallback PK.
+            if (!sourceObj) {
+                LogError(`[buildTargetConfigs] Skipping "${obj.SourceObjectName}" — not found in source schema (IntrospectSchema may have failed for this object)`);
+                continue;
+            }
             // Filter fields if caller specified a subset
             const selectedFieldSet = obj.Fields?.length
                 ? new Set(obj.Fields.map(f => f.toLowerCase()))
                 : null;
-            const sourceFields = (sourceObj?.Fields ?? []).filter(f => !selectedFieldSet || selectedFieldSet.has(f.Name.toLowerCase()) || f.IsPrimaryKey);
+            const sourceFields = sourceObj.Fields.filter(f => !selectedFieldSet || selectedFieldSet.has(f.Name.toLowerCase()) || f.IsPrimaryKey);
             const columns = sourceFields.map(f => ({
                 SourceFieldName: f.Name,
                 TargetColumnName: f.Name.replace(/[^A-Za-z0-9_]/g, '_'),
@@ -1732,20 +1784,34 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 DefaultValue: f.DefaultValue,
                 Description: f.Description ?? objDescriptions?.fields.get(f.Name.toLowerCase()),
             }));
-            const primaryKeyFields = (sourceObj?.Fields ?? [])
+            const primaryKeyFields = sourceObj.Fields
                 .filter(f => f.IsPrimaryKey)
                 .map(f => f.Name.replace(/[^A-Za-z0-9_]/g, '_'));
-            return {
+            // If no columns were discovered, skip rather than generating a broken table
+            // (DDL with UNIQUE ([ID]) on a non-existent column will always fail).
+            if (columns.length === 0 && primaryKeyFields.length === 0) {
+                LogError(`[buildTargetConfigs] Skipping "${obj.SourceObjectName}" — 0 fields discovered (live API likely failed and no DB-cached fields available)`);
+                continue;
+            }
+            // If columns exist but no PK was found, log diagnostic info and skip rather than
+            // generating broken DDL with UNIQUE ([ID]) on a non-existent column.
+            if (primaryKeyFields.length === 0 && columns.length > 0) {
+                const fieldNames = sourceObj.Fields.map(f => `${f.Name}(pk=${f.IsPrimaryKey})`).join(', ');
+                LogError(`[buildTargetConfigs] Skipping "${obj.SourceObjectName}" — ${columns.length} columns but NO primary key field found. Fields: [${fieldNames}]`);
+                continue;
+            }
+            results.push({
                 SourceObjectName: obj.SourceObjectName,
                 SchemaName: obj.SchemaName,
                 TableName: obj.TableName,
                 EntityName: obj.EntityName,
-                Description: sourceObj?.Description ?? objDescriptions?.objectDescription,
+                Description: sourceObj.Description ?? objDescriptions?.objectDescription,
                 Columns: columns,
-                PrimaryKeyFields: primaryKeyFields.length > 0 ? primaryKeyFields : ['ID'],
+                PrimaryKeyFields: primaryKeyFields,
                 SoftForeignKeys: []
-            };
-        });
+            });
+        }
+        return results;
     }
     /** Builds a lookup of object name → { objectDescription, fields: fieldName → description } from the connector's static metadata. */
     /** Build ExistingTableInfo[] from MJ Metadata for tables that already exist in the target schemas. */
@@ -2403,8 +2469,68 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             // Step 1: Resolve connector and derive schema name
             const { connector, companyIntegration } = await this.resolveConnector(input.CompanyIntegrationID, user);
             const schemaName = this.deriveSchemaName(companyIntegration.Integration);
-            // Step 2: Resolve object IDs to names, build inputs with per-object Fields
+            // Step 1b: Ensure IntegrationEngine cache is populated so IntrospectSchema's
+            // DB fallback (GetCachedObject/GetCachedFields) can find IntegrationObject records
+            await IntegrationEngine.Instance.Config(false, user);
+            // Step 2: Introspect source schema and persist discovered objects/fields
             const sourceSchema = await connector.IntrospectSchema.bind(connector)(companyIntegration, user);
+            // Step 2b: Persist discovered objects/fields to IntegrationObject/IntegrationObjectField.
+            // Static records (IsCustom=false) are preserved; new/custom records get IsCustom=true.
+            // This ensures custom objects are available for future sync runs, action generation, etc.
+            try {
+                const persistResult = await IntegrationSchemaSync.PersistDiscoveredSchema({
+                    IntegrationID: companyIntegration.IntegrationID,
+                    SourceSchema: sourceSchema,
+                    ContextUser: user,
+                });
+                if (persistResult.ObjectsCreated > 0 || persistResult.FieldsCreated > 0) {
+                    console.log(`[IntegrationApplyAll] Persisted discovered schema: ` +
+                        `${persistResult.ObjectsCreated} new objects, ${persistResult.FieldsCreated} new fields, ` +
+                        `${persistResult.ObjectsUpdated} updated objects, ${persistResult.FieldsUpdated} updated fields`);
+                }
+                // Step 2c: Generate CRUD actions for newly discovered custom objects.
+                // Uses the same ActionMetadataGenerator as the offline CLI, persisted via BaseEntity.Save().
+                if (persistResult.ObjectsCreated > 0) {
+                    try {
+                        const engineObjects = IntegrationEngine.Instance
+                            .GetIntegrationObjectsByIntegrationID(companyIntegration.IntegrationID);
+                        const customObjects = sourceSchema.Objects
+                            .filter(o => !engineObjects
+                            .some(ex => ex.Name.toLowerCase() === o.ExternalName.toLowerCase() && !ex.IsCustom))
+                            .map(o => ({
+                            Name: o.ExternalName,
+                            DisplayName: o.ExternalLabel || o.ExternalName,
+                            Description: o.Description,
+                            SupportsWrite: false,
+                            Fields: o.Fields.map(f => ({
+                                Name: f.Name,
+                                DisplayName: f.Label || f.Name,
+                                Description: f.Description || '',
+                                Type: f.SourceType || 'string',
+                                IsRequired: f.IsRequired,
+                                IsReadOnly: false,
+                                IsPrimaryKey: f.IsPrimaryKey,
+                            })),
+                        }));
+                        await IntegrationSchemaSync.GenerateActionsForCustomObjects({
+                            IntegrationName: companyIntegration.Integration,
+                            CustomObjects: customObjects,
+                            SupportsSearch: connector.SupportsSearch,
+                            SupportsListing: connector.SupportsListing,
+                            ContextUser: user,
+                        });
+                    }
+                    catch (actionErr) {
+                        const msg = actionErr instanceof Error ? actionErr.message : String(actionErr);
+                        console.warn(`[IntegrationApplyAll] Action generation warning (non-fatal): ${msg}`);
+                    }
+                }
+            }
+            catch (persistErr) {
+                // Non-fatal: schema persistence failure should not block table creation
+                const msg = persistErr instanceof Error ? persistErr.message : String(persistErr);
+                console.warn(`[IntegrationApplyAll] Schema persistence warning (non-fatal): ${msg}`);
+            }
             const objectIDs = input.SourceObjects.map(so => so.SourceObjectID);
             const resolvedNames = await this.resolveSourceObjectNames(objectIDs, undefined, sourceSchema, companyIntegration.IntegrationID, user);
             // Build SchemaPreviewObjectInput with Fields carried from SourceObjectInput
@@ -2472,7 +2598,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             // If skipRestart=true, we can do entity maps now.
             if (skipRestart) {
                 await Metadata.Provider.Refresh();
-                const entityMapsCreated = await this.createEntityAndFieldMaps(input.CompanyIntegrationID, objects, connector, companyIntegration, schemaName, user);
+                const entityMapsCreated = await this.createEntityAndFieldMaps(input.CompanyIntegrationID, objects, connector, companyIntegration, schemaName, user, input.DefaultSyncDirection ?? 'Pull');
                 const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
                 const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
                 const syncRunID = input.StartSync !== false
@@ -2539,11 +2665,11 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
      * After pipeline success, creates CompanyIntegrationEntityMap + CompanyIntegrationFieldMap
      * records for each source object by matching schema + table name to newly created entities.
      */
-    async createEntityAndFieldMaps(companyIntegrationID, objects, connector, companyIntegration, schemaName, user) {
+    async createEntityAndFieldMaps(companyIntegrationID, objects, connector, companyIntegration, schemaName, user, defaultSyncDirection = 'Pull') {
         const md = new Metadata();
         const results = [];
         for (const obj of objects) {
-            const entityMapResult = await this.createSingleEntityMap(companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md);
+            const entityMapResult = await this.createSingleEntityMap(companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md, defaultSyncDirection);
             if (entityMapResult) {
                 results.push(entityMapResult);
             }
@@ -2551,7 +2677,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
         return results;
     }
     /** Creates a single entity map + field maps for one source object. */
-    async createSingleEntityMap(companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md) {
+    async createSingleEntityMap(companyIntegrationID, obj, connector, companyIntegration, schemaName, user, md, defaultSyncDirection = 'Pull') {
         // Find the entity by schema + table name
         const entityInfo = md.Entities.find(e => e.SchemaName.toLowerCase() === schemaName.toLowerCase()
             && e.BaseTable.toLowerCase() === obj.TableName.toLowerCase());
@@ -2565,8 +2691,8 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
         em.CompanyIntegrationID = companyIntegrationID;
         em.ExternalObjectName = obj.SourceObjectName;
         em.EntityID = entityInfo.ID;
-        em.SyncDirection = 'Pull';
-        em.Priority = 0;
+        em.SyncDirection = isValidSyncDirection(defaultSyncDirection) ? defaultSyncDirection : 'Pull';
+        em.Priority = obj.SourceObjectName.startsWith('assoc_') ? 10 : 0;
         em.Status = 'Active';
         em.SyncEnabled = true;
         if (!await em.Save()) {
@@ -2687,7 +2813,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
      * Starts an async integration sync. Returns immediately with the run ID.
      * Sends a webhook to the registered callback when complete.
      */
-    async IntegrationStartSync(companyIntegrationID, webhookURL, fullSync, entityMapIDs, ctx) {
+    async IntegrationStartSync(companyIntegrationID, webhookURL, fullSync, entityMapIDs, syncDirection, ctx) {
         try {
             const user = this.getAuthenticatedUser(ctx);
             await IntegrationEngine.Instance.Config(false, user);
@@ -2696,6 +2822,8 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 syncOptions.FullSync = true;
             if (entityMapIDs?.length)
                 syncOptions.EntityMapIDs = entityMapIDs;
+            if (syncDirection)
+                syncOptions.SyncDirection = syncDirection;
             // Fire and forget — progress is tracked inside IntegrationEngine
             const syncPromise = IntegrationEngine.Instance.RunSync(companyIntegrationID, user, 'Manual', undefined, undefined, Object.keys(syncOptions).length > 0 ? syncOptions : undefined);
             syncPromise
@@ -2765,6 +2893,74 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             return { Success: false, Message: this.formatError(e) };
         }
     }
+    /**
+     * Writes a single record to an external system via the integration connector.
+     * Supports create, update, and delete operations.
+     */
+    async IntegrationWriteRecord(companyIntegrationID, objectName, operation, externalID, attributesJson, ctx) {
+        try {
+            const user = this.getAuthenticatedUser(ctx);
+            await IntegrationEngine.Instance.Config(false, user);
+            const rv = new RunView();
+            const ciResult = await rv.RunView({
+                EntityName: 'MJ: Company Integrations',
+                ExtraFilter: `ID='${companyIntegrationID}'`,
+                MaxRows: 1,
+                ResultType: 'entity_object',
+            }, user);
+            if (!ciResult.Success || ciResult.Results.length === 0) {
+                return { Success: false, Message: `Company Integration not found: ${companyIntegrationID}` };
+            }
+            const companyIntegration = ciResult.Results[0];
+            // Load the Integration entity to get the ClassName for connector resolution
+            const integResult = await rv.RunView({
+                EntityName: 'Integrations',
+                ExtraFilter: `ID='${companyIntegration.IntegrationID}'`,
+                MaxRows: 1,
+                ResultType: 'entity_object',
+            }, user);
+            if (!integResult.Success || integResult.Results.length === 0) {
+                return { Success: false, Message: `Integration not found: ${companyIntegration.IntegrationID}` };
+            }
+            const connector = ConnectorFactory.Resolve(integResult.Results[0]);
+            const attributes = attributesJson ? JSON.parse(attributesJson) : {};
+            const crudBase = { CompanyIntegration: companyIntegration, ObjectName: objectName, ContextUser: user };
+            let result;
+            switch (operation.toLowerCase()) {
+                case 'create':
+                    if (!connector.SupportsCreate)
+                        return { Success: false, Message: 'Connector does not support create' };
+                    result = await connector.CreateRecord({ ...crudBase, Attributes: attributes });
+                    break;
+                case 'update':
+                    if (!connector.SupportsUpdate)
+                        return { Success: false, Message: 'Connector does not support update' };
+                    if (!externalID)
+                        return { Success: false, Message: 'externalID is required for update' };
+                    result = await connector.UpdateRecord({ ...crudBase, ExternalID: externalID, Attributes: attributes });
+                    break;
+                case 'delete':
+                    if (!connector.SupportsDelete)
+                        return { Success: false, Message: 'Connector does not support delete' };
+                    if (!externalID)
+                        return { Success: false, Message: 'externalID is required for delete' };
+                    result = await connector.DeleteRecord({ ...crudBase, ExternalID: externalID });
+                    break;
+                default:
+                    return { Success: false, Message: `Invalid operation: ${operation}. Must be create, update, or delete` };
+            }
+            return {
+                Success: result.Success,
+                Message: result.Success ? `${operation} succeeded` : (result.ErrorMessage ?? `${operation} failed`),
+                ExternalID: result.ExternalID,
+                StatusCode: result.StatusCode,
+            };
+        }
+        catch (e) {
+            LogError(`IntegrationWriteRecord error: ${e}`);
+            return { Success: false, Message: this.formatError(e) };
+        }
+    }
     // ── SCHEDULE ────────────────────────────────────────────────────────
     async IntegrationCreateSchedule(input, ctx) {
         try {
@@ -2793,7 +2989,12 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
             job.Timezone = input.Timezone || 'UTC';
             job.Status = 'Active';
             job.OwnerUserID = user.ID;
-            job.Configuration = JSON.stringify({ CompanyIntegrationID: input.CompanyIntegrationID });
+            const jobConfig = { CompanyIntegrationID: input.CompanyIntegrationID };
+            if (input.SyncDirection)
+                jobConfig.SyncDirection = input.SyncDirection;
+            if (input.FullSync)
+                jobConfig.FullSync = input.FullSync;
+            job.Configuration = JSON.stringify(jobConfig);
             job.NextRunAt = CronExpressionHelper.GetNextRunTime(input.CronExpression, input.Timezone || 'UTC');
             if (!await job.Save())
                 return { Success: false, Message: 'Failed to create schedule' };
@@ -3296,6 +3497,15 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
         try {
             const user = this.getAuthenticatedUser(ctx);
             const validatedPlatform = this.validatePlatform(platform);
+            // Bust RunView caches for integration metadata BEFORE Config(true).
+            // mj sync push writes records via stored procedures which do NOT fire
+            // BaseEntity change events, so the RunView cache is never auto-invalidated.
+            // Explicitly clearing these entries ensures Config(true) re-queries the DB.
+            await LocalCacheManager.Instance.InvalidateEntityCaches('MJ: Integration Objects');
+            await LocalCacheManager.Instance.InvalidateEntityCaches('MJ: Integration Object Fields');
+            // Force-refresh integration metadata cache so IntrospectSchema
+            // picks up any IntegrationObject/Field changes made via mj sync push
+            await IntegrationEngine.Instance.Config(true, user);
             // Phase 1: Build schema for each connector in parallel
             const buildResults = await Promise.allSettled(input.Connectors.map(async (connInput) => {
                 const { connector, companyIntegration } = await this.resolveConnector(connInput.CompanyIntegrationID, user);
@@ -3337,6 +3547,8 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                     StartSync: input.StartSync,
                     FullSync: input.FullSync ?? false,
                     SyncScope: input.SyncScope ?? 'created',
+                    SyncDirection: input.SyncDirection,
+                    ScheduleSyncDirection: input.ScheduleSyncDirection,
                     CreatedAt: new Date().toISOString(),
                 };
                 rsuInput.PostRestartFiles = [
@@ -3415,7 +3627,7 @@ let IntegrationDiscoveryResolver = class IntegrationDiscoveryResolver extends Re
                 if (skipRestart) {
                     // Entity maps, field maps, sync
                     await Metadata.Provider.Refresh();
-                    const entityMapsCreated = await this.createEntityAndFieldMaps(build.connInput.CompanyIntegrationID, build.objects, build.connector, build.companyIntegration, build.schemaName, user);
+                    const entityMapsCreated = await this.createEntityAndFieldMaps(build.connInput.CompanyIntegrationID, build.objects, build.connector, build.companyIntegration, build.schemaName, user, build.connInput.DefaultSyncDirection ?? 'Pull');
                     connResult.EntityMapsCreated = entityMapsCreated;
                     const createdMapIDs = entityMapsCreated.map(em => em.EntityMapID).filter(Boolean);
                     const scopedMapIDs = input.SyncScope === 'all' ? undefined : createdMapIDs;
@@ -3995,9 +4207,10 @@ __decorate([
     __param(1, Arg("webhookURL", { nullable: true })),
     __param(2, Arg("fullSync", () => Boolean, { defaultValue: false, description: 'If true, ignores watermarks and re-fetches all records from the source' })),
     __param(3, Arg("entityMapIDs", () => [String], { nullable: true, description: 'Optional: sync only these entity maps. If omitted, syncs all maps for the connector.' })),
-    __param(4, Ctx()),
+    __param(4, Arg("syncDirection", () => String, { nullable: true, description: 'Override sync direction: Pull | Push | Bidirectional. If omitted, each entity map\'s own SyncDirection is used.' })),
+    __param(5, Ctx()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, Boolean, Array, Object]),
+    __metadata("design:paramtypes", [String, String, Boolean, Array, String, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationStartSync", null);
 __decorate([
@@ -4008,6 +4221,18 @@ __decorate([
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
 ], IntegrationDiscoveryResolver.prototype, "IntegrationCancelSync", null);
+__decorate([
+    Mutation(() => WriteRecordOutput),
+    __param(0, Arg("companyIntegrationID")),
+    __param(1, Arg("objectName")),
+    __param(2, Arg("operation", () => String, { description: 'create, update, or delete' })),
+    __param(3, Arg("externalID", { nullable: true, description: 'Required for update/delete' })),
+    __param(4, Arg("attributes", () => String, { nullable: true, description: 'JSON object of field values for create/update' })),
+    __param(5, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String, String, Object]),
+    __metadata("design:returntype", Promise)
+], IntegrationDiscoveryResolver.prototype, "IntegrationWriteRecord", null);
 __decorate([
     Mutation(() => CreateScheduleOutput),
     __param(0, Arg("input")),