fix: split between DBOnEventScript and OnEventScript

packages/server/lib/controllers/sync/deploy/postConfirmation.integration.test.ts

@@ -1,6 +1,6 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { isError, isSuccess, runServer, shouldBeProtected } from '../../../utils/tests.js';
-import { eventTypeMapper, seeders } from '@nangohq/shared';
+import { seeders } from '@nangohq/shared';
 
 const endpoint = '/sync/deploy/confirmation';
 let api: Awaited<ReturnType<typeof runServer>>;
@@ -123,7 +123,7 @@ describe(`POST ${endpoint}`, () => {
                 {
                     name: existingOnEvent.name,
                     providerConfigKey: existingOnEvent.providerConfigKey,
-                    event: eventTypeMapper.fromDb(existingOnEvent.event)
+                    event: existingOnEvent.event
                 }
             ]
         });

packages/server/lib/controllers/sync/deploy/postConfirmation.ts

@@ -1,7 +1,7 @@
 import { requireEmptyQuery, zodErrorToHTTP } from '@nangohq/utils';
 import type { PostDeployConfirmation, ScriptDifferences } from '@nangohq/types';
 import { asyncWrapper } from '../../../utils/asyncWrapper.js';
-import { eventTypeMapper, getAndReconcileDifferences, onEventScriptService } from '@nangohq/shared';
+import { getAndReconcileDifferences, onEventScriptService } from '@nangohq/shared';
 import { getOrchestrator } from '../../../utils/utils.js';
 import { logContextGetter } from '@nangohq/logs';
 import { validation } from './validation.js';
@@ -50,14 +50,14 @@ export const postDeployConfirmation = asyncWrapper<PostDeployConfirmation>(async
                 return {
                     providerConfigKey: script.providerConfigKey,
                     name: script.name,
-                    event: eventTypeMapper.fromDb(script.event)
+                    event: script.event
                 };
             }),
             deletedOnEventScripts: diff.deleted.map((script) => {
                 return {
                     providerConfigKey: script.providerConfigKey,
                     name: script.name,
-                    event: eventTypeMapper.fromDb(script.event)
+                    event: script.event
                 };
             })
         };

packages/shared/lib/seeders/onEventScript.seeder.ts

@@ -9,7 +9,7 @@ export async function createOnEventScript({
     account: DBTeam;
     environment: DBEnvironment;
     providerConfigKey: string;
-}): Promise<OnEventScript & { providerConfigKey: string }> {
+}): Promise<OnEventScript> {
     const scripts: OnEventScriptsByProvider[] = [
         {
             providerConfigKey,

packages/shared/lib/services/on-event-scripts.service.ts

@@ -1,31 +1,61 @@
 import db from '@nangohq/database';
 import remoteFileService from './file/remote.service.js';
 import { env } from '@nangohq/utils';
-import type { OnEventScriptsByProvider, OnEventScript, DBTeam, DBEnvironment, OnEventType } from '@nangohq/types';
+import type { OnEventScriptsByProvider, DBOnEventScript, DBTeam, DBEnvironment, OnEventType, OnEventScript } from '@nangohq/types';
 import { increment } from './sync/config/config.service.js';
 import configService from './config.service.js';
 
 const TABLE = 'on_event_scripts';
 
-const EVENT_TYPE_MAPPINGS: Record<OnEventScript['event'], OnEventType> = {
+const EVENT_TYPE_MAPPINGS: Record<DBOnEventScript['event'], OnEventType> = {
     POST_CONNECTION_CREATION: 'post-connection-creation',
     PRE_CONNECTION_DELETION: 'pre-connection-deletion'
 } as const;
 
-export const eventTypeMapper = {
-    fromDb: (event: OnEventScript['event']): OnEventType => {
+const eventTypeMapper = {
+    fromDb: (event: DBOnEventScript['event']): OnEventType => {
         return EVENT_TYPE_MAPPINGS[event];
     },
-    toDb: (eventType: OnEventType): OnEventScript['event'] => {
+    toDb: (eventType: OnEventType): DBOnEventScript['event'] => {
         for (const [key, value] of Object.entries(EVENT_TYPE_MAPPINGS)) {
             if (value === eventType) {
-                return key as OnEventScript['event'];
+                return key as DBOnEventScript['event'];
             }
         }
         throw new Error(`Unknown event type: ${eventType}`); // This should never happen
     }
 };
 
+const dbMapper = {
+    to: (script: OnEventScript): DBOnEventScript => {
+        return {
+            id: script.id,
+            config_id: script.configId,
+            name: script.name,
+            file_location: script.fileLocation,
+            version: script.version,
+            active: script.active,
+            event: eventTypeMapper.toDb(script.event),
+            created_at: script.createdAt,
+            updated_at: script.updatedAt
+        };
+    },
+    from: (dbScript: DBOnEventScript & { provider_config_key: string }): OnEventScript => {
+        return {
+            id: dbScript.id,
+            configId: dbScript.config_id,
+            providerConfigKey: dbScript.provider_config_key,
+            name: dbScript.name,
+            fileLocation: dbScript.file_location,
+            version: dbScript.version,
+            active: dbScript.active,
+            event: eventTypeMapper.fromDb(dbScript.event),
+            createdAt: dbScript.created_at,
+            updatedAt: dbScript.updated_at
+        };
+    }
+};
+
 export const onEventScriptService = {
     async update({
         environment,
@@ -35,14 +65,14 @@ export const onEventScriptService = {
         environment: DBEnvironment;
         account: DBTeam;
         onEventScriptsByProvider: OnEventScriptsByProvider[];
-    }): Promise<(OnEventScript & { providerConfigKey: string })[]> {
+    }): Promise<OnEventScript[]> {
         return db.knex.transaction(async (trx) => {
-            const onEventInserts: Omit<OnEventScript, 'id' | 'created_at' | 'updated_at'>[] = [];
+            const onEventInserts: Omit<DBOnEventScript, 'id' | 'created_at' | 'updated_at'>[] = [];
 
             // Deactivate all previous scripts for the environment
             // This is done to ensure that we don't have any orphaned scripts when they are removed from nango.yaml
             const previousScriptVersions = await trx
-                .from<OnEventScript>(TABLE)
+                .from<DBOnEventScript>(TABLE)
                 .whereRaw(`config_id IN (SELECT id FROM _nango_configs WHERE environment_id = ?)`, [environment.id])
                 .where({
                     active: true
@@ -94,58 +124,63 @@ export const onEventScriptService = {
                 }
             }
             if (onEventInserts.length > 0) {
-                type R = Awaited<ReturnType<typeof onEventScriptService.update>>;
                 const res = await trx
                     .with('inserted', (qb) => {
                         qb.insert(onEventInserts).into(TABLE).returning('*');
                     })
-                    .select<R>(['inserted.*', '_nango_configs.unique_key as providerConfigKey'])
+                    .select<(DBOnEventScript & { provider_config_key: string })[]>(['inserted.*', '_nango_configs.unique_key as provider_config_key'])
                     .from('inserted')
                     .join('_nango_configs', 'inserted.config_id', '_nango_configs.id');
-                return res;
+                return res.map(dbMapper.from);
             }
             return [];
         });
     },
-    getByConfig: async (configId: number, event: OnEventType): Promise<OnEventScript[]> => {
-        return db.knex.from<OnEventScript>(TABLE).where({ config_id: configId, active: true, event: eventTypeMapper.toDb(event) });
+
+    getByEnvironmentId: async (environmentId: number): Promise<OnEventScript[]> => {
+        const existingScriptsQuery = await db.knex
+            .select<(DBOnEventScript & { provider_config_key: string })[]>(`${TABLE}.*`, '_nango_configs.unique_key as provider_config_key')
+            .from(TABLE)
+            .join('_nango_configs', `${TABLE}.config_id`, '_nango_configs.id')
+            .where({
+                '_nango_configs.environment_id': environmentId,
+                [`${TABLE}.active`]: true
+            });
+        return existingScriptsQuery.map(dbMapper.from);
+    },
+
+    getByConfig: async (configId: number, event: OnEventType): Promise<DBOnEventScript[]> => {
+        return db.knex.from<DBOnEventScript>(TABLE).where({ config_id: configId, active: true, event: eventTypeMapper.toDb(event) });
     },
+
     diffChanges: async ({
         environmentId,
         onEventScriptsByProvider
     }: {
         environmentId: number;
         onEventScriptsByProvider: OnEventScriptsByProvider[];
     }): Promise<{
-        added: (Omit<OnEventScript, 'id' | 'file_location' | 'created_at' | 'updated_at'> & { providerConfigKey: string })[];
-        deleted: (OnEventScript & { providerConfigKey: string })[];
-        updated: (OnEventScript & { providerConfigKey: string })[];
+        added: Omit<OnEventScript, 'id' | 'fileLocation' | 'createdAt' | 'updatedAt'>[];
+        deleted: OnEventScript[];
+        updated: OnEventScript[];
     }> => {
         const res: Awaited<ReturnType<typeof onEventScriptService.diffChanges>> = {
             added: [],
             deleted: [],
             updated: []
         };
 
-        const existingScripts = await db.knex
-            .select<(OnEventScript & { providerConfigKey: string })[]>(`${TABLE}.*`, '_nango_configs.unique_key as providerConfigKey')
-            .from(TABLE)
-            .join('_nango_configs', `${TABLE}.config_id`, '_nango_configs.id')
-            .where({
-                '_nango_configs.environment_id': environmentId,
-                [`${TABLE}.active`]: true
-            });
+        const existingScripts = await onEventScriptService.getByEnvironmentId(environmentId);
 
         // Create a map of existing scripts for easier lookup
-        const existingMap = new Map(existingScripts.map((script) => [`${script.config_id}:${script.name}:${script.event}`, script]));
+        const existingMap = new Map(existingScripts.map((script) => [`${script.configId}:${script.name}:${script.event}`, script]));
 
         for (const provider of onEventScriptsByProvider) {
             const config = await configService.getProviderConfig(provider.providerConfigKey, environmentId);
             if (!config || !config.id) continue;
 
             for (const script of provider.scripts) {
-                const event = eventTypeMapper.toDb(script.event);
-                const key = `${config.id}:${script.name}:${event}`;
+                const key = `${config.id}:${script.name}:${script.event}`;
 
                 const maybeScript = existingMap.get(key);
                 if (maybeScript) {
@@ -157,11 +192,11 @@ export const onEventScriptService = {
                 } else {
                     // Script doesn't exist - it's new
                     res.added.push({
-                        config_id: config.id,
+                        configId: config.id,
                         name: script.name,
                         version: '0.0.1',
                         active: true,
-                        event,
+                        event: script.event,
                         providerConfigKey: provider.providerConfigKey
                     });
                 }

packages/types/lib/deploy/api.ts

@@ -3,7 +3,7 @@ import type { JSONSchema7 } from 'json-schema';
 import type { Endpoint, ApiError } from '../api.js';
 import type { IncomingFlowConfig, OnEventScriptsByProvider } from './incomingFlow.js';
 import type { SyncDeploymentResult } from './index.js';
-import type { OnEventType } from '../nangoYaml/index.js';
+import type { OnEventType } from '../scripts/on-events/api.js';
 
 export type PostDeployConfirmation = Endpoint<{
     Method: 'POST';

packages/types/lib/deploy/incomingFlow.ts

@@ -1,5 +1,6 @@
 import type { Merge } from 'type-fest';
-import type { NangoModel, NangoSyncEndpointOld, NangoSyncEndpointV2, OnEventType, ScriptTypeLiteral, SyncTypeLiteral } from '../nangoYaml';
+import type { NangoModel, NangoSyncEndpointOld, NangoSyncEndpointV2, ScriptTypeLiteral, SyncTypeLiteral } from '../nangoYaml';
+import type { OnEventType } from '../scripts/on-events/api';
 
 export interface IncomingScriptFiles {
     js: string;

packages/types/lib/index.ts

@@ -27,6 +27,7 @@ export type * from './proxy/api.js';
 
 export type * from './environment/db.js';
 export type * from './scripts/on-events/db.js';
+export type * from './scripts/on-events/api.js';
 export type * from './scripts/syncs/api.js';
 export type * from './slackNotifications/db.js';
 export type * from './notification/active-logs/db.js';

packages/types/lib/nangoYaml/index.ts

@@ -1,3 +1,5 @@
+import type { OnEventType } from '../scripts/on-events/api';
+
 export type HTTP_METHOD = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
 export type SyncTypeLiteral = 'incremental' | 'full';
 export type ScriptFileType = 'actions' | 'syncs' | 'on-events' | 'post-connection-scripts'; // post-connection-scripts is deprecated
@@ -80,8 +82,6 @@ export type NangoYamlModelField = boolean | number | string | null | string[] |
 export type NangoYaml = NangoYamlV1 | NangoYamlV2;
 
 // -------------- Parsed
-export type OnEventType = 'post-connection-creation' | 'pre-connection-deletion';
-
 export interface NangoYamlParsed {
     yamlVersion: 'v1' | 'v2';
     integrations: NangoYamlParsedIntegration[];

packages/types/lib/scripts/on-events/api.ts

@@ -0,0 +1,16 @@
+import type { DBOnEventScript } from './db.js';
+
+export type OnEventType = 'post-connection-creation' | 'pre-connection-deletion';
+
+export interface OnEventScript {
+    id: DBOnEventScript['id'];
+    configId: DBOnEventScript['config_id'];
+    providerConfigKey: string;
+    name: DBOnEventScript['name'];
+    fileLocation: DBOnEventScript['file_location'];
+    version: DBOnEventScript['version'];
+    active: DBOnEventScript['active'];
+    event: OnEventType;
+    createdAt: DBOnEventScript['created_at'];
+    updatedAt: DBOnEventScript['updated_at'];
+}

packages/types/lib/scripts/on-events/db.ts

@@ -1,6 +1,6 @@
 import type { Timestamps } from '../../db.js';
 
-export interface OnEventScript extends Timestamps {
+export interface DBOnEventScript extends Timestamps {
     id: number;
     config_id: number;
     name: string;