@sixb/core 0.1.1 → 0.1.2

package/src/syncs/execution.ts

@@ -0,0 +1,78 @@
+import { isAllowed } from "../authorization"
+import type { ExecutionContext } from "../execution"
+import type { SixbRuntimeContext } from "../runtime/types"
+import type {
+  ListLatestSyncRunsResult,
+  ListSyncRunsInput,
+  ListSyncRunsResult,
+  SyncRunRecord,
+} from "../storage/sync-runs"
+import { SyncValidationError } from "./errors"
+import { type RequestSyncRunInput, requestSyncRun, type SyncRunRequestResult } from "./request"
+import type { SyncDefinition } from "./types"
+
+export interface SyncRunsRuntime {
+  getById(runId: string): Promise<SyncRunRecord | null>
+  list(input?: Omit<ListSyncRunsInput, "projectId" | "syncIds">): Promise<ListSyncRunsResult>
+  listLatest(syncIds: readonly string[]): Promise<ListLatestSyncRunsResult>
+}
+
+export interface SyncsRuntime {
+  list(): readonly SyncDefinition[]
+  getById(syncId: string): SyncDefinition | null
+  request(input: RequestSyncRunInput): Promise<SyncRunRequestResult>
+  readonly runs: SyncRunsRuntime
+}
+
+export function createSyncsRuntime(
+  runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
+  source: Pick<SyncsRuntime, "list" | "getById">
+): SyncsRuntime {
+  const allowed = (syncId: string) => isAllowed(runtime.authorization, { kind: "sync.run", syncId })
+  const visibleIds = () =>
+    source
+      .list()
+      .filter((sync) => allowed(sync.id))
+      .map((sync) => sync.id)
+
+  return {
+    list: () => source.list().filter((sync) => allowed(sync.id)),
+    getById: (syncId) => {
+      const sync = source.getById(syncId)
+      return sync && allowed(syncId) ? sync : null
+    },
+    request: async (input) => {
+      const sync = source.getById(input.syncId)
+      if (!sync) throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`)
+      return requestSyncRun(runtime, execution, sync, input)
+    },
+    runs: {
+      getById: async (runId) => {
+        const run =
+          (await runtime.storage.syncRuns?.getById({
+            projectId: runtime.projectId,
+            id: runId,
+          })) ?? null
+        return run && allowed(run.syncId) ? run : null
+      },
+      list: (input = {}) => {
+        const storage = runtime.storage.syncRuns
+        if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        return storage.list({
+          projectId: runtime.projectId,
+          ...input,
+          syncIds: runtime.authorization ? visibleIds() : undefined,
+        })
+      },
+      listLatest: (syncIds) => {
+        const storage = runtime.storage.syncRuns
+        if (!storage || syncIds.length === 0) return Promise.resolve({ runs: [] })
+        const allowedIds = syncIds.filter(allowed)
+        return allowedIds.length === 0
+          ? Promise.resolve({ runs: [] })
+          : storage.listLatestBySyncIds({ projectId: runtime.projectId, syncIds: allowedIds })
+      },
+    },
+  }
+}

package/src/syncs/index.ts

@@ -6,12 +6,25 @@ export type {
   SyncRunRequestResult,
 } from "./request"
 export { requestSyncRun } from "./request"
+export {
+  type AutomaticSyncExecutionSource,
+  type AutomaticSyncRunDispatchInput,
+  SyncRunDispatcher,
+  type SyncRunDispatcherDependencies,
+  type SyncRunDispatchPort,
+} from "./run-dispatch"
+export {
+  resolveSyncConnectorSources,
+  type SyncConnectorSource,
+  type SyncConnectorSourceResolver,
+} from "./sources"
 export type {
   BatchSyncConfig,
   BatchSyncDefinitionConfig,
   DatasetSyncTarget,
   SyncBlobContext,
   SyncBuilder,
+  SyncConnectorConnection,
   SyncDefinition,
   SyncMode,
   SyncReadBuilder,

package/src/syncs/request.ts

@@ -1,15 +1,17 @@
-import { randomUUID } from "node:crypto"
 import { assertAuthorized } from "../authorization"
+import {
+  createPrimitiveExecutionRecord,
+  ensureExecutionRecord,
+  executionRecordInputFromRuntime,
+} from "../execution/durable"
+import type { ExecutionContext } from "../execution/types"
 import type { SixbRuntimeContext } from "../runtime/types"
 import { SyncValidationError } from "./errors"
+import { dispatchSyncRun } from "./run-dispatch"
 import type { SyncDefinition } from "./types"
 
 export interface SyncRunRequestOptions {
-  /**
-   * Identity of the run to create. Deduplicated when a worker claims the job, not here: two requests
-   * carrying the same id enqueue two jobs, and the second `start()` loses to the unique run id and
-   * no-ops. So one run happens, but this call cannot tell you whether it was yours.
-   */
+  /** Stable identity used to make dispatch idempotent. */
   readonly runId?: string
   /** Optimistic concurrency guard: fail the run if the dataset moved past this version. */
   readonly expectedLatestVersionId?: string
@@ -23,9 +25,10 @@ export interface RequestSyncRunInput extends SyncRunRequestOptions {
 export interface SyncRunRequestResult {
   readonly syncId: string
   readonly runId: string
-  /** When the job was enqueued. Not persisted — the run row records `startedAt` instead. */
+  /** Durable time at which the run entered the queue. */
   readonly queuedAt: string
   readonly jobId?: string
+  readonly created: boolean
 }
 
 /**
@@ -34,18 +37,11 @@ export interface SyncRunRequestResult {
  * Operates on an already-resolved definition and the shared runtime context, so the HTTP route and
  * the runtime verb cannot drift apart.
  *
- * A sync run row is created by the worker that claims the job, not here — `SyncRunStatus` has no
- * `queued` member, unlike `WorkflowRunStatus`. So this reports "the request is accepted", where
- * `requestWorkflowRun` reports "the run exists" and can therefore return `created`. Aligning the two
- * means giving sync and pipeline runs a queued state across every storage provider, which is a
- * lifecycle change rather than a field; `created` can be added here afterwards without breaking
- * anyone, since nothing implements this result type.
- *
- * The storage precondition below is checked even though nothing here writes: accepting a request the
- * worker will refuse is worse than failing now.
+ * The immutable child execution and queued run are persisted before queue publication.
  */
 export async function requestSyncRun(
   runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
   sync: SyncDefinition,
   options: SyncRunRequestOptions = {}
 ): Promise<SyncRunRequestResult> {
@@ -59,33 +55,26 @@ export async function requestSyncRun(
     throw new SyncValidationError("[Sixb] Sync run queue is not configured.")
   }
 
-  const runId = createSyncRunId(options.runId)
-  const queuedAt = new Date().toISOString()
-  const [job] = await queue.enqueue({
+  return dispatchSyncRun({
+    errorReporterHost: runtime,
     projectId: runtime.projectId,
-    jobs: [
-      {
-        type: "sync.run.requested",
-        payload: {
-          syncId: sync.id,
-          runId,
-          expectedLatestVersionId: options.expectedLatestVersionId,
-          commitMessage: options.commitMessage,
-        },
-      },
-    ],
+    sync,
+    storage: runtime.storage,
+    queue,
+    ...options,
+    createExecution: async (executionId, runId) => {
+      const caller = await ensureExecutionRecord(
+        runtime.storage.executions,
+        executionRecordInputFromRuntime({
+          execution,
+          runtimeAuthorization: runtime.runtimeAuthorization,
+        })
+      )
+      return createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "sync", id: sync.id, runId },
+        origin: { type: "execution", parent: caller },
+      })
+    },
   })
-
-  return { syncId: sync.id, runId, queuedAt, jobId: job?.id }
-}
-
-function createSyncRunId(runId: string | undefined): string {
-  if (runId !== undefined) {
-    if (!runId.trim()) {
-      throw new SyncValidationError("[Sixb] Sync run id must not be empty")
-    }
-    return runId
-  }
-
-  return `run_${randomUUID()}`
 }

package/src/syncs/run-dispatch.ts

@@ -0,0 +1,312 @@
+import { randomUUID } from "node:crypto"
+import { reportRunFailure } from "../error-reporting/capability"
+import { createSixbError, toSixbFailure } from "../errors/internal"
+import type { SixbFailure } from "../errors/types"
+import type { RunDispatcher } from "../execution/dispatch"
+import { createPrimitiveExecutionRecord } from "../execution/durable"
+import type { Queues } from "../queues"
+import type { SixbDefinitions } from "../runtime/definitions"
+import type { CreateExecutionInput, Storage, SyncRunFailureCode, SyncRunRecord } from "../storage"
+import { SYNC_RUN_FAILURE_CODES, SyncRunError } from "../storage"
+import { SyncValidationError } from "./errors"
+import type { SyncRunRequestOptions, SyncRunRequestResult } from "./request"
+import type { SyncDefinition } from "./types"
+
+export type AutomaticSyncExecutionSource =
+  | { readonly type: "schedule"; readonly eventId: string }
+  | { readonly type: "event"; readonly eventId: string }
+
+export interface AutomaticSyncRunDispatchInput extends SyncRunRequestOptions {
+  readonly syncId: string
+  readonly runId: string
+  readonly source: AutomaticSyncExecutionSource
+  readonly correlationId: string
+  readonly metadata?: Readonly<Record<string, string>>
+}
+
+export type SyncRunDispatchPort = RunDispatcher<AutomaticSyncRunDispatchInput, SyncRunRequestResult>
+
+export interface SyncRunDispatcherDependencies {
+  readonly id: string
+  readonly definitions: Pick<SixbDefinitions, "syncs">
+  readonly storage: Storage
+  readonly queues: Pick<Queues, "syncRuns">
+}
+
+interface DispatchSyncRunInput extends SyncRunRequestOptions {
+  readonly errorReporterHost: object
+  readonly projectId: string
+  readonly sync: SyncDefinition
+  readonly storage: Storage
+  readonly queue: Queues["syncRuns"]
+  readonly metadata?: Readonly<Record<string, string>>
+  readonly createExecution: (executionId: string, runId: string) => Promise<CreateExecutionInput>
+  readonly validateExistingRun?: (run: SyncRunRecord, storage: Storage) => Promise<void>
+}
+
+type PersistedSyncRun =
+  | { readonly publish: false; readonly run: SyncRunRecord }
+  | {
+      readonly publish: true
+      readonly run: SyncRunRecord
+      readonly execution: CreateExecutionInput
+      readonly queuedAt: Date
+      readonly created: boolean
+    }
+
+/** Core-owned durable dispatch boundary used by automatic Sync triggers. */
+export class SyncRunDispatcher implements SyncRunDispatchPort {
+  constructor(private readonly dependencies: SyncRunDispatcherDependencies) {}
+
+  async dispatch(input: AutomaticSyncRunDispatchInput): Promise<SyncRunRequestResult> {
+    assertAutomaticDispatchInput(input)
+    const sync = this.dependencies.definitions.syncs.getById(input.syncId)
+    if (!sync) throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`)
+
+    return dispatchSyncRun({
+      errorReporterHost: this.dependencies,
+      projectId: this.dependencies.id,
+      sync,
+      storage: this.dependencies.storage,
+      queue: this.dependencies.queues.syncRuns,
+      runId: input.runId,
+      expectedLatestVersionId: input.expectedLatestVersionId,
+      commitMessage: input.commitMessage,
+      metadata: input.metadata,
+      validateExistingRun: (run, storage) =>
+        assertAutomaticExecutionIdentity(storage, this.dependencies.id, input, run),
+      createExecution: async (executionId, runId) =>
+        createPrimitiveExecutionRecord({
+          id: executionId,
+          primitive: { kind: "sync", id: sync.id, runId },
+          origin: {
+            type: "automatic",
+            projectId: this.dependencies.id,
+            source: input.source,
+            correlationId: input.correlationId,
+          },
+        }),
+    })
+  }
+}
+
+/** Persist a Sync execution and queued run before publishing its queue job. */
+export async function dispatchSyncRun(input: DispatchSyncRunInput): Promise<SyncRunRequestResult> {
+  const runId = createSyncRunId(input.runId)
+  const persisted = await persistSyncRun(input, runId)
+  if (!persisted.publish) return existingSyncRunResult(persisted.run)
+  return publishSyncRun(input, persisted)
+}
+
+async function persistSyncRun(
+  input: DispatchSyncRunInput,
+  runId: string
+): Promise<PersistedSyncRun> {
+  const syncRuns = requireSyncRunStorage(input.storage)
+  const existing = await syncRuns.getById({ projectId: input.projectId, id: runId })
+  if (existing) return reuseSyncRun(input, existing)
+
+  const execution = await input.createExecution(`exec_${randomUUID()}`, runId)
+  const queuedAt = new Date()
+  try {
+    return await input.storage.transaction(
+      async (tx): Promise<PersistedSyncRun> => {
+        const transactionalRuns = requireSyncRunStorage(tx)
+        const raced = await transactionalRuns.getById({ projectId: input.projectId, id: runId })
+        if (raced) {
+          assertExistingRunMatchesRequest(raced, input)
+          await input.validateExistingRun?.(raced, tx)
+          return { publish: false, run: raced }
+        }
+
+        await tx.executions.create(execution)
+        const run = await transactionalRuns.queue({
+          projectId: input.projectId,
+          id: runId,
+          executionId: execution.id,
+          syncId: input.sync.id,
+          datasetId: input.sync.target.dataset.id,
+          mode: input.sync.config.mode,
+          queuedAt,
+          expectedLatestVersionId: input.expectedLatestVersionId,
+          commitMessage: input.commitMessage,
+        })
+        return { publish: true, run, execution, queuedAt, created: true }
+      },
+      { isolation: "serializable" }
+    )
+  } catch (error) {
+    if (!(error instanceof SyncRunError)) throw error
+    const raced = await syncRuns.getById({ projectId: input.projectId, id: runId })
+    if (!raced) throw error
+    assertExistingRunMatchesRequest(raced, input)
+    await input.validateExistingRun?.(raced, input.storage)
+    return { publish: false, run: raced }
+  }
+}
+
+async function reuseSyncRun(
+  input: DispatchSyncRunInput,
+  existing: SyncRunRecord
+): Promise<PersistedSyncRun> {
+  assertExistingRunMatchesRequest(existing, input)
+  await input.validateExistingRun?.(existing, input.storage)
+  if (
+    existing.status !== "failed" ||
+    existing.error?.code !== "queue.enqueue_failed" ||
+    !existing.error.retryable
+  ) {
+    return { publish: false, run: existing }
+  }
+
+  const execution = await input.storage.executions.getById({
+    projectId: input.projectId,
+    id: existing.executionId,
+  })
+  if (!execution) {
+    throw new SyncRunError(
+      `[Sixb] Execution '${existing.executionId}' for Sync run '${existing.id}' was not found.`
+    )
+  }
+
+  const queuedAt = new Date()
+  const run = await requireSyncRunStorage(input.storage).queue({
+    projectId: input.projectId,
+    id: existing.id,
+    executionId: existing.executionId,
+    syncId: existing.syncId,
+    datasetId: existing.datasetId,
+    mode: existing.mode,
+    queuedAt,
+    expectedLatestVersionId: existing.expectedLatestVersionId,
+    commitMessage: existing.commitMessage,
+  })
+  return { publish: true, run, execution, queuedAt, created: false }
+}
+
+async function publishSyncRun(
+  input: DispatchSyncRunInput,
+  persisted: Extract<PersistedSyncRun, { readonly publish: true }>
+): Promise<SyncRunRequestResult> {
+  try {
+    const [job] = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: [
+        {
+          id: persisted.run.id,
+          type: "sync.run.requested",
+          payload: { runId: persisted.run.id },
+          ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+        },
+      ],
+    })
+    return {
+      syncId: persisted.run.syncId,
+      runId: persisted.run.id,
+      queuedAt: persisted.queuedAt.toISOString(),
+      ...(job?.id ? { jobId: job.id } : {}),
+      created: persisted.created,
+    }
+  } catch (error) {
+    const failedAt = new Date()
+    const failure = toEnqueueFailure(error, persisted.run, failedAt)
+    const failed = await requireSyncRunStorage(input.storage).finish({
+      projectId: input.projectId,
+      id: persisted.run.id,
+      status: "failed",
+      finishedAt: failedAt,
+      error: failure,
+    })
+    reportRunFailure(input.errorReporterHost, error, {
+      projectId: input.projectId,
+      runKind: "sync",
+      run: { runId: failed.id, syncId: failed.syncId },
+      failure,
+    })
+    throw error
+  }
+}
+
+function assertExistingRunMatchesRequest(
+  existing: SyncRunRecord,
+  input: Pick<DispatchSyncRunInput, "sync" | "expectedLatestVersionId" | "commitMessage">
+): void {
+  if (
+    existing.syncId !== input.sync.id ||
+    existing.datasetId !== input.sync.target.dataset.id ||
+    existing.mode !== input.sync.config.mode ||
+    existing.expectedLatestVersionId !== input.expectedLatestVersionId ||
+    existing.commitMessage !== input.commitMessage
+  ) {
+    throw new SyncRunError(
+      `[Sixb] Sync run '${existing.id}' already exists with a different request payload.`
+    )
+  }
+}
+
+function existingSyncRunResult(existing: SyncRunRecord): SyncRunRequestResult {
+  return {
+    syncId: existing.syncId,
+    runId: existing.id,
+    queuedAt: existing.queuedAt.toISOString(),
+    created: false,
+  }
+}
+
+function requireSyncRunStorage(storage: Storage): NonNullable<Storage["syncRuns"]> {
+  if (!storage.syncRuns) throw new SyncValidationError("[Sixb] Sync run storage is not configured.")
+  return storage.syncRuns
+}
+
+function createSyncRunId(runId: string | undefined): string {
+  if (runId === undefined) return `run_${randomUUID()}`
+  if (!runId.trim()) throw new SyncValidationError("[Sixb] Sync run id must not be empty")
+  return runId
+}
+
+function assertAutomaticDispatchInput(input: AutomaticSyncRunDispatchInput): void {
+  assertNonBlank(input.syncId, "Sync id")
+  assertNonBlank(input.runId, "Sync run id")
+  assertNonBlank(input.source.eventId, "Sync source event id")
+  assertNonBlank(input.correlationId, "Sync correlation id")
+}
+
+async function assertAutomaticExecutionIdentity(
+  storage: Storage,
+  projectId: string,
+  input: AutomaticSyncRunDispatchInput,
+  run: SyncRunRecord
+): Promise<void> {
+  const execution = await storage.executions.getById({ projectId, id: run.executionId })
+  if (
+    !execution ||
+    execution.source.type !== input.source.type ||
+    execution.source.eventId !== input.source.eventId ||
+    execution.correlationId !== input.correlationId ||
+    execution.requestedBy !== undefined
+  ) {
+    throw new SyncValidationError(
+      `[Sixb] Sync run '${run.id}' already exists with different automatic provenance.`
+    )
+  }
+}
+
+function toEnqueueFailure(
+  error: unknown,
+  run: SyncRunRecord,
+  at: Date
+): SixbFailure<SyncRunFailureCode> {
+  const enqueueError = createSixbError(
+    "queue.enqueue_failed",
+    `[Sixb] Could not enqueue Sync run '${run.id}'.`,
+    {
+      cause: error,
+      details: { syncId: run.syncId, runId: run.id, phase: "enqueue" },
+    }
+  )
+  return toSixbFailure(enqueueError, { allowedCodes: SYNC_RUN_FAILURE_CODES, at })
+}
+
+function assertNonBlank(value: string, label: string): void {
+  if (!value.trim()) throw new SyncValidationError(`[Sixb] ${label} must not be empty.`)
+}

package/src/syncs/sources.ts

@@ -0,0 +1,20 @@
+import type { AnyConnectorAdapter, ConnectorDefinition, ConnectorRuntime } from "../connectors"
+import {
+  type ConnectorExecutionSource,
+  type ConnectorExecutionSourceResolver,
+  getConnectorExecutionSourceResolver,
+} from "../connectors/execution"
+
+/** One connector client invocation contributing values to a Sync run. */
+export type SyncConnectorSource<TAdapter extends AnyConnectorAdapter = AnyConnectorAdapter> =
+  ConnectorExecutionSource<TAdapter>
+
+export type SyncConnectorSourceResolver = ConnectorExecutionSourceResolver
+
+/** Resolve the source invocations owned by one connector definition for a Sync execution. */
+export function resolveSyncConnectorSources<TAdapter extends AnyConnectorAdapter>(
+  connector: ConnectorRuntime,
+  definition: ConnectorDefinition<string, TAdapter>
+): Promise<readonly SyncConnectorSource<TAdapter>[]> {
+  return getConnectorExecutionSourceResolver(connector).list(definition)
+}

package/src/syncs/types.ts

@@ -1,9 +1,12 @@
 import type { BlobStorage } from "../blob-storage"
 import {
+  type AnyConnectorAdapter,
   type ConnectorAdapter,
   type ConnectorClient,
+  type ConnectorConnectionMetadata,
   type ConnectorDefinition,
   isConnectorDefinition,
+  type OAuthConnectorAdapter,
 } from "../connectors"
 import type { DatasetDefinition, DatasetPrimaryKey, MergeChange } from "../datasets"
 import { isDatasetDefinition } from "../datasets"
@@ -14,8 +17,19 @@ import { isScheduleReference } from "../schedules"
 /** Blob operations available to sync read handlers. */
 export type SyncBlobContext = Pick<BlobStorage, "put" | "open" | "stat">
 
+/** Non-secret connector connection metadata available to OAuth-backed Sync handlers. */
+export type SyncConnectorConnection = ConnectorConnectionMetadata
+
+type SyncConnectionContext<TAdapter extends AnyConnectorAdapter> =
+  TAdapter extends OAuthConnectorAdapter
+    ? { readonly connection: SyncConnectorConnection }
+    : { readonly connection?: undefined }
+
 /** Context passed to a sync read handler. */
-export type SyncReadContext<TCheckpoint = never> = {
+export type SyncReadContext<
+  TCheckpoint = never,
+  TAdapter extends AnyConnectorAdapter = ConnectorAdapter,
+> = {
   readonly projectId: string
   readonly syncId: string
   readonly signal: AbortSignal
@@ -26,7 +40,8 @@ export type SyncReadContext<TCheckpoint = never> = {
   : {
       readonly checkpoint?: TCheckpoint
       setCheckpoint(next: TCheckpoint): void
-    })
+    }) &
+  SyncConnectionContext<TAdapter>
 
 export type SyncMode = "snapshot" | "append" | "merge"
 
@@ -66,13 +81,13 @@ export interface DatasetSyncTarget {
  * they author a sync.
  */
 export type SyncReadHandler<
-  TAdapter extends ConnectorAdapter,
+  TAdapter extends AnyConnectorAdapter,
   TCheckpoint = never,
   TMode extends SyncMode = SyncMode,
 > = {
   bivarianceHack(
     client: ConnectorClient<TAdapter>,
-    context: SyncReadContext<TCheckpoint>
+    context: SyncReadContext<TCheckpoint, TAdapter>
   ): SyncReadResult<TMode> | Promise<SyncReadResult<TMode>>
 }["bivarianceHack"]
 
@@ -84,7 +99,10 @@ export type SyncReadHandler<
  */
 export interface SyncDefinition<
   TId extends string = string,
-  TConnector extends ConnectorDefinition = ConnectorDefinition,
+  TConnector extends ConnectorDefinition<string, AnyConnectorAdapter> = ConnectorDefinition<
+    string,
+    AnyConnectorAdapter
+  >,
   TCheckpoint = unknown,
   TMode extends SyncMode = SyncMode,
 > {
@@ -99,7 +117,10 @@ export interface SyncDefinition<
 
 export interface SyncTargetBuilder<
   TId extends string = string,
-  TConnector extends ConnectorDefinition = ConnectorDefinition,
+  TConnector extends ConnectorDefinition<string, AnyConnectorAdapter> = ConnectorDefinition<
+    string,
+    AnyConnectorAdapter
+  >,
   TCheckpoint = never,
   TMode extends SyncMode = SyncMode,
 > {
@@ -112,7 +133,10 @@ export interface SyncTargetBuilder<
 
 export interface SyncReadBuilder<
   TId extends string = string,
-  TConnector extends ConnectorDefinition = ConnectorDefinition,
+  TConnector extends ConnectorDefinition<string, AnyConnectorAdapter> = ConnectorDefinition<
+    string,
+    AnyConnectorAdapter
+  >,
   TCheckpoint = never,
   TMode extends SyncMode = SyncMode,
 > {
@@ -128,7 +152,7 @@ export interface SyncBuilder<
 > {
   when(schedule: ScheduleDefinition): SyncBuilder<TId, TCheckpoint, TMode>
   checkpoint<TNextCheckpoint>(): SyncBuilder<TId, TNextCheckpoint, TMode>
-  from<TConnector extends ConnectorDefinition>(
+  from<TConnector extends ConnectorDefinition<string, AnyConnectorAdapter>>(
     connector: TConnector
   ): SyncReadBuilder<TId, TConnector, TCheckpoint, TMode>
 }