@pattern-stack/codegen 0.10.1 → 0.11.0

package/dist/runtime/subsystems/index.js

@@ -4016,23 +4016,23 @@ import { Module as Module6 } from "@nestjs/common";
 // runtime/subsystems/observability/observability.service.ts
 import { Inject as Inject13, Injectable as Injectable14, Optional as Optional7 } from "@nestjs/common";
 
-// runtime/subsystems/sync/sync.tokens.ts
-var SYNC_CURSOR_STORE = "SYNC_CURSOR_STORE";
-var SYNC_RUN_RECORDER = "SYNC_RUN_RECORDER";
+// runtime/subsystems/integration/integration.tokens.ts
+var INTEGRATION_CURSOR_STORE = "INTEGRATION_CURSOR_STORE";
+var INTEGRATION_RUN_RECORDER = "INTEGRATION_RUN_RECORDER";
 
 // runtime/subsystems/observability/observability.service.ts
 var MAX_TIMELINE_PAGES = 50;
 var ObservabilityService = class {
-  constructor(jobRuns2, bridge, syncRuns, cursors, events) {
+  constructor(jobRuns2, bridge, integrationRuns, cursors, events) {
     this.jobRuns = jobRuns2;
     this.bridge = bridge;
-    this.syncRuns = syncRuns;
+    this.integrationRuns = integrationRuns;
     this.cursors = cursors;
     this.events = events;
   }
   jobRuns;
   bridge;
-  syncRuns;
+  integrationRuns;
   cursors;
   events;
   async getPoolDepths(tenantId) {
@@ -4047,9 +4047,9 @@ var ObservabilityService = class {
     if (!this.bridge) return { ...ObservabilityService.EMPTY_HISTOGRAM };
     return this.bridge.getStatusHistogram(windowHours, tenantId);
   }
-  async getRecentSyncRuns(limit, subscriptionId, tenantId) {
-    if (!this.syncRuns) return [];
-    return this.syncRuns.listRecent(limit, subscriptionId, tenantId);
+  async getRecentIntegrationRuns(limit, subscriptionId, tenantId) {
+    if (!this.integrationRuns) return [];
+    return this.integrationRuns.listRecent(limit, subscriptionId, tenantId);
   }
   async getCursors(tenantId) {
     if (!this.cursors) return [];
@@ -4173,9 +4173,9 @@ ObservabilityService = __decorateClass([
   __decorateParam(1, Optional7()),
   __decorateParam(1, Inject13(BRIDGE_DELIVERY_REPO)),
   __decorateParam(2, Optional7()),
-  __decorateParam(2, Inject13(SYNC_RUN_RECORDER)),
+  __decorateParam(2, Inject13(INTEGRATION_RUN_RECORDER)),
   __decorateParam(3, Optional7()),
-  __decorateParam(3, Inject13(SYNC_CURSOR_STORE)),
+  __decorateParam(3, Inject13(INTEGRATION_CURSOR_STORE)),
   __decorateParam(4, Optional7()),
   __decorateParam(4, Inject13(EVENT_READ_PORT))
 ], ObservabilityService);
@@ -4300,25 +4300,25 @@ var OAuthStateError = class extends Error {
 // runtime/subsystems/auth/auth.tokens.ts
 var ENCRYPTION_KEY = /* @__PURE__ */ Symbol("ENCRYPTION_KEY");
 var OAUTH_STATE_STORE = /* @__PURE__ */ Symbol("OAUTH_STATE_STORE");
-var AUTH_INTEGRATION_READER = /* @__PURE__ */ Symbol("AUTH_INTEGRATION_READER");
-var AUTH_INTEGRATION_TOKEN_WRITER = /* @__PURE__ */ Symbol("AUTH_INTEGRATION_TOKEN_WRITER");
-var AUTH_INTEGRATION_GRANT_SINK = /* @__PURE__ */ Symbol("AUTH_INTEGRATION_GRANT_SINK");
+var AUTH_CONNECTION_READER = /* @__PURE__ */ Symbol("AUTH_CONNECTION_READER");
+var AUTH_CONNECTION_TOKEN_WRITER = /* @__PURE__ */ Symbol("AUTH_CONNECTION_TOKEN_WRITER");
+var AUTH_CONNECTION_GRANT_SINK = /* @__PURE__ */ Symbol("AUTH_CONNECTION_GRANT_SINK");
 var AUTH_USER_CONTEXT = /* @__PURE__ */ Symbol("AUTH_USER_CONTEXT");
 var STRATEGY_REGISTRY = /* @__PURE__ */ Symbol("STRATEGY_REGISTRY");
 var AUTH_OPTIONS = /* @__PURE__ */ Symbol("AUTH_OPTIONS");
 
-// runtime/subsystems/auth/runtime/integration-broken.error.ts
-var IntegrationBrokenError = class extends Error {
-  constructor(integrationId, errorCode, errorDescription) {
+// runtime/subsystems/auth/runtime/connection-broken.error.ts
+var ConnectionBrokenError = class extends Error {
+  constructor(connectionId, errorCode, errorDescription) {
     super(
-      `Integration ${integrationId} broken: ${errorCode} - ${errorDescription}`
+      `Connection ${connectionId} broken: ${errorCode} - ${errorDescription}`
     );
-    this.integrationId = integrationId;
+    this.connectionId = connectionId;
     this.errorCode = errorCode;
     this.errorDescription = errorDescription;
-    this.name = "IntegrationBrokenError";
+    this.name = "ConnectionBrokenError";
   }
-  integrationId;
+  connectionId;
   errorCode;
   errorDescription;
 };
@@ -4326,53 +4326,53 @@ var IntegrationBrokenError = class extends Error {
 // runtime/subsystems/auth/runtime/oauth2-refresh.strategy.ts
 var REFRESH_SAFETY_MS = 5 * 60 * 1e3;
 var OAuth2RefreshStrategy = class {
-  integrationReader;
+  connectionReader;
   tokenWriter;
   fetchImpl;
   now;
   constructor(opts) {
-    this.integrationReader = opts.integrationReader;
+    this.connectionReader = opts.connectionReader;
     this.tokenWriter = opts.tokenWriter;
     this.fetchImpl = opts.fetch ?? fetch;
     this.now = opts.now ?? Date.now;
   }
-  async resolve(integrationId, opts = {}) {
-    const integration = await this.integrationReader.findByIdDecrypted(integrationId);
-    if (!integration) {
-      throw new Error(`Integration ${integrationId} not found`);
+  async resolve(connectionId, opts = {}) {
+    const connection = await this.connectionReader.findByIdDecrypted(connectionId);
+    if (!connection) {
+      throw new Error(`Connection ${connectionId} not found`);
     }
-    if (integration.provider !== this.provider) {
+    if (connection.provider !== this.provider) {
       throw new Error(
-        `${this.constructor.name} called for non-${this.provider} integration ${integrationId} (provider=${integration.provider})`
+        `${this.constructor.name} called for non-${this.provider} connection ${connectionId} (provider=${connection.provider})`
       );
     }
-    const needsRefresh = opts.forceRefresh || this.isExpiring(integration.expiresAt) || !integration.accessToken;
+    const needsRefresh = opts.forceRefresh || this.isExpiring(connection.expiresAt) || !connection.accessToken;
     if (!needsRefresh) {
-      return this.buildCredentials(integration.accessToken, integration);
+      return this.buildCredentials(connection.accessToken, connection);
     }
-    if (!integration.refreshToken) {
-      throw new IntegrationBrokenError(
-        integrationId,
+    if (!connection.refreshToken) {
+      throw new ConnectionBrokenError(
+        connectionId,
         "no_refresh_token",
-        "Integration has no refresh token; user must reconnect"
+        "Connection has no refresh token; user must reconnect"
       );
     }
     const { parsed, raw } = await this.executeRefresh(
-      integrationId,
-      integration.refreshToken
+      connectionId,
+      connection.refreshToken
     );
     const newExpiresAt = new Date(
       this.now() + (parsed.expiresInSec ?? this.defaultExpiresInSec) * 1e3
     );
     await this.tokenWriter.persistRefresh({
-      integrationId,
+      connectionId,
       accessToken: parsed.accessToken,
       refreshToken: parsed.refreshToken ?? void 0,
       expiresAt: newExpiresAt
     });
-    return this.buildCredentials(parsed.accessToken, integration, raw);
+    return this.buildCredentials(parsed.accessToken, connection, raw);
   }
-  async executeRefresh(integrationId, refreshToken) {
+  async executeRefresh(connectionId, refreshToken) {
     const body = new URLSearchParams({
       grant_type: "refresh_token",
       refresh_token: refreshToken,
@@ -4386,8 +4386,8 @@ var OAuth2RefreshStrategy = class {
     if (!response.ok) {
       const err = await safeJson(response);
       if (response.status === 400 && (err.error === "invalid_grant" || err.error === "invalid_token")) {
-        throw new IntegrationBrokenError(
-          integrationId,
+        throw new ConnectionBrokenError(
+          connectionId,
           err.error ?? "invalid_grant",
           err.error_description ?? err.message ?? "refresh token rejected"
         );
@@ -4430,14 +4430,14 @@ function isSessionExpiredError(err) {
 }
 
 // runtime/subsystems/auth/runtime/with-auth-retry.ts
-async function withAuthRetry(authStrategy, integrationId, op, options = {}) {
+async function withAuthRetry(authStrategy, connectionId, op, options = {}) {
   const classify = options.isSessionExpired ?? isSessionExpiredError;
-  let creds = await authStrategy.resolve(integrationId);
+  let creds = await authStrategy.resolve(connectionId);
   try {
     return await op(creds);
   } catch (e) {
     if (!classify(e)) throw e;
-    creds = await authStrategy.resolve(integrationId, { forceRefresh: true });
+    creds = await authStrategy.resolve(connectionId, { forceRefresh: true });
     return op(creds);
   }
 }
@@ -4647,7 +4647,7 @@ var AuthController = class {
     });
     return res.redirect(
       HttpStatus.FOUND,
-      redirect ?? `/settings/integrations?connected=${encodeURIComponent(slug)}`
+      redirect ?? `/settings/connections?connected=${encodeURIComponent(slug)}`
     );
   }
   requireStrategy(slug) {
@@ -4690,7 +4690,7 @@ AuthController = __decorateClass([
   __decorateParam(0, Inject15(STRATEGY_REGISTRY)),
   __decorateParam(1, Inject15(AUTH_USER_CONTEXT)),
   __decorateParam(2, Inject15(OAUTH_STATE_STORE)),
-  __decorateParam(3, Inject15(AUTH_INTEGRATION_GRANT_SINK)),
+  __decorateParam(3, Inject15(AUTH_CONNECTION_GRANT_SINK)),
   __decorateParam(4, Inject15(AUTH_OPTIONS))
 ], AuthController);
 
@@ -4762,15 +4762,16 @@ AuthModule = __decorateClass([
   Module7({})
 ], AuthModule);
 export {
-  AUTH_INTEGRATION_GRANT_SINK,
-  AUTH_INTEGRATION_READER,
-  AUTH_INTEGRATION_TOKEN_WRITER,
+  AUTH_CONNECTION_GRANT_SINK,
+  AUTH_CONNECTION_READER,
+  AUTH_CONNECTION_TOKEN_WRITER,
   AUTH_OPTIONS,
   AUTH_USER_CONTEXT,
   AuthController,
   AuthModule,
   CACHE,
   CacheModule,
+  ConnectionBrokenError,
   DrizzleCacheService,
   DrizzleEventBus,
   DrizzleOAuthStateStore,
@@ -4778,7 +4779,6 @@ export {
   EVENT_BUS,
   EnvEncryptionKey,
   EventsModule,
-  IntegrationBrokenError,
   LocalStorageBackend,
   MemoryCacheService,
   MemoryEventBus,