studiograph 1.3.8 → 1.3.9

package/dist/services/sync/collection-sync.js

@@ -1,9 +1,12 @@
 /**
- * Collection-Scoped Sync Runner
+ * Sync Runner
  *
- * Given a collection with sync rules, connects to sources via MCP,
- * extracts records, derives secondary entities, deduplicates against
- * existing entities, and writes new entities to the collection.
+ * Unified sync pipeline: fetch from source once, distribute to target collections.
+ * Both collection-level and workspace-level rules use the same syncSource() function.
+ * Collection rules are converted to workspace-rule shape with a single target.
+ *
+ * Supports server-side filter optimization: when there is exactly one target with
+ * server-mode filter keys, those are merged into list_params before extraction.
  *
  * Sync-once semantics: existing entities (matched by source_ref) are
  * never updated during a pull. Use entity-refresh for single-entity updates.
@@ -38,7 +41,7 @@ function createDataFetcher(connectorConfig, definition, opts) {
                 headers['Authorization'] = `Bearer ${oauthData.tokens.access_token}`;
             }
         }
-        // Resolve query-param auth (e.g. api_token for Pipedrive)
+        // Resolve env vars in query auth params
         const queryAuth = {};
         if (definition.rest.query_auth) {
             for (const [k, v] of Object.entries(definition.rest.query_auth)) {
@@ -48,10 +51,9 @@ function createDataFetcher(connectorConfig, definition, opts) {
         return new RESTClient(definition.rest.base_url, headers, definition.entities, queryAuth);
     }
     // MCP adapter (default)
-    const known = KNOWN_CONNECTORS[connectorConfig.name];
-    const auth = connectorConfig.auth ?? known?.auth;
+    const auth = connectorConfig.auth ?? KNOWN_CONNECTORS[connectorConfig.name]?.auth;
     if (auth === 'oauth' && opts?.userId && opts?.authService && opts?.serverUrl) {
-        const provider = new ServerOAuthProvider(connectorConfig.name, opts.userId, opts.authService, opts.serverUrl, known?.oauth);
+        const provider = new ServerOAuthProvider(connectorConfig.name, opts.userId, opts.authService, opts.serverUrl);
         return new SyncMCPClient(connectorConfig, provider);
     }
     if (auth === 'oauth') {
@@ -60,129 +62,31 @@ function createDataFetcher(connectorConfig, definition, opts) {
     return new SyncMCPClient(connectorConfig);
 }
 /**
- * Run sync for a collection. Processes each sync rule in the collection's config.
- */
-export async function syncCollection(options) {
-    const { workspacePath, collectionName, workspaceConfig, schemaExtensions, onProgress, userId, authService, serverUrl } = options;
-    const log = onProgress ?? (() => { });
-    // Find collection config
-    const repoConfig = workspaceConfig.repos.find(r => r.name === collectionName);
-    if (!repoConfig) {
-        throw new Error(`Collection "${collectionName}" not found in workspace config`);
-    }
-    const syncRules = repoConfig.sync;
-    if (!syncRules || syncRules.length === 0) {
-        throw new Error(`Collection "${collectionName}" has no sync rules configured`);
-    }
-    const results = [];
-    for (const rule of syncRules) {
-        log(`\nSyncing from source: ${rule.source}`);
-        try {
-            const result = await syncOneRule({
-                workspacePath,
-                repoConfig,
-                rule,
-                workspaceConfig,
-                schemaExtensions,
-                onProgress,
-                userId,
-                authService,
-                serverUrl,
-            });
-            results.push(result);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log(`  Error: ${msg}`);
-            results.push({
-                collection: collectionName,
-                source: rule.source,
-                created: 0,
-                skipped: 0,
-                derived: 0,
-                errors: [msg],
-            });
-        }
-    }
-    return results;
-}
-/**
- * Run all sync rules that apply to a collection:
- * - Collection-level rules (if the collection has its own sync array)
- * - Workspace-level rules that include this collection as a target
+ * Unified sync function: fetch from source once, distribute to all targets.
  *
- * This is the preferred entry point for per-collection sync — it handles both
- * rule types without callers needing to know the distinction.
- */
-export async function syncRepo(options) {
-    const { workspacePath, collectionName, workspaceConfig, schemaExtensions, onProgress, userId, authService, serverUrl } = options;
-    const log = onProgress ?? (() => { });
-    const collectionResults = [];
-    const workspaceResults = [];
-    // Run collection-level rules (if any)
-    const repoConfig = workspaceConfig.repos.find(r => r.name === collectionName);
-    const collectionRules = repoConfig?.sync;
-    if (collectionRules && collectionRules.length > 0) {
-        const results = await syncCollection({ workspacePath, collectionName, workspaceConfig, schemaExtensions, onProgress, userId, authService, serverUrl });
-        collectionResults.push(...results);
-    }
-    // Run workspace-level rules that target this collection
-    const workspaceRules = workspaceConfig.sync ?? [];
-    for (const rule of workspaceRules) {
-        const matchingTargets = rule.targets.filter(t => t.repo === collectionName);
-        if (matchingTargets.length === 0)
-            continue;
-        log(`\nSyncing workspace rule: ${rule.source} → ${collectionName}`);
-        try {
-            const result = await syncWorkspaceRule({
-                workspacePath,
-                rule: { ...rule, targets: matchingTargets },
-                workspaceConfig,
-                schemaExtensions,
-                onProgress,
-                userId,
-                authService,
-                serverUrl,
-            });
-            workspaceResults.push(result);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            log(`  Error: ${msg}`);
-            workspaceResults.push({
-                source: rule.source,
-                targets: matchingTargets.map(t => ({ repo: t.repo, created: 0, skipped: 0, derived: 0, errors: [msg] })),
-            });
-        }
-    }
-    if (collectionResults.length === 0 && workspaceResults.length === 0) {
-        throw new Error(`Collection "${collectionName}" has no sync rules configured (collection-level or workspace-level)`);
-    }
-    return { collectionResults, workspaceResults };
-}
-/**
- * Run one workspace-level sync rule: fetch from source once, distribute to all targets.
- * Each target receives a filtered subset of the extracted records.
+ * Both collection-level and workspace-level rules use this single code path.
+ * Collection rules are converted to workspace rules with a single target by syncRepo().
  */
-export async function syncWorkspaceRule(options) {
+export async function syncSource(options) {
     const { workspacePath, rule, workspaceConfig, schemaExtensions, onProgress, userId, authService, serverUrl } = options;
     const log = onProgress ?? (() => { });
     const result = { source: rule.source, targets: [] };
+    // ── Resolve source definition ───────────────────────────────────────────────
     const configMgr = new SourceConfigManager(workspacePath);
     const definition = configMgr.getDefinition(rule.source);
-    const oldConfig = !definition ? configMgr.get(rule.source) : null;
-    if (!definition && !oldConfig) {
-        throw new Error(`Source "${rule.source}" not found in .studiograph/sources/`);
+    if (!definition) {
+        throw new Error(`Source "${rule.source}" not found. Ensure a source definition exists (built-in or .studiograph/sources/).`);
     }
-    const connectorName = definition?.connector ?? oldConfig.connector;
+    const connectorName = definition.connector;
     const connectorConfigs = ConnectorManager.loadConfigs(workspacePath);
     const connectorConfig = connectorConfigs.find(c => c.name === connectorName);
     if (!connectorConfig) {
         throw new Error(`Connector "${connectorName}" not configured. Run: studiograph connector add ${connectorName}`);
     }
+    // ── Connect ─────────────────────────────────────────────────────────────────
     const client = createDataFetcher(connectorConfig, definition, { userId, authService, serverUrl });
     try {
-        log(`  Connecting to ${connectorName}${definition?.adapter === 'rest' ? ' (REST)' : ''}...`);
+        log(`  Connecting to ${connectorName}${definition.adapter === 'rest' ? ' (REST)' : ''}...`);
         try {
             await client.connect();
         }
@@ -193,41 +97,36 @@ export async function syncWorkspaceRule(options) {
         log(`  Available tools: ${client.getTools().map(t => t.name).join(', ')}`);
         const schemaRegistry = new SchemaRegistry(schemaExtensions);
         const syncState = new SyncStateManager(workspacePath);
-        // ── Extract ALL records once (no target filter at this stage) ──────────────
+        const filterFieldDefs = definition.filter_fields ?? SOURCE_DEFINITIONS[connectorName]?.filter_fields ?? [];
+        // ── Resolve primary entity type ───────────────────────────────────────────
+        const primaryType = rule.entity_type ?? findPrimaryType(definition);
+        const primaryConfig = definition.entities[primaryType];
+        if (!primaryConfig) {
+            throw new Error(`Entity type "${primaryType}" not found in source definition "${rule.source}"`);
+        }
+        // ── Server-side filter optimization ───────────────────────────────────────
+        // When there is exactly one target, merge server-mode filter keys into list_params
+        const serverFilter = computeServerFilter(rule.targets, filterFieldDefs);
+        const mapping = sourceEntityConfigToMapping(primaryType, primaryConfig, rule.source, '_sync_', serverFilter);
+        const extractorConfig = {
+            name: rule.source,
+            connector: definition.connector,
+            enabled: true,
+            added_at: new Date().toISOString(),
+            entity_mappings: [mapping],
+        };
+        // ── Extract ─────────────────────────────────────────────────────────────────
+        log(`  Extracting ${primaryType} records...`);
         let allRecords;
-        const filterFieldDefs = definition?.filter_fields ?? SOURCE_DEFINITIONS[connectorName]?.filter_fields ?? [];
-        if (definition) {
-            const primaryType = rule.entity_type ?? findPrimaryType(definition);
-            const primaryConfig = definition.entities[primaryType];
-            if (!primaryConfig) {
-                throw new Error(`Entity type "${primaryType}" not found in source definition`);
-            }
-            // Extract without any filter — filtering happens per-target below
-            const mapping = sourceEntityConfigToMapping(primaryType, primaryConfig, rule.source, '_workspace_', undefined);
-            const oldStyleConfig = {
-                name: rule.source,
-                connector: definition.connector,
-                enabled: true,
-                added_at: new Date().toISOString(),
-                entity_mappings: [mapping],
-            };
-            log(`  Extracting ${primaryType} records...`);
-            if (primaryConfig.extraction_mode === 'frontmatter') {
-                const extractor = new FrontmatterExtractor(client, oldStyleConfig);
-                allRecords = await extractor.extract(mapping, onProgress);
-            }
-            else {
-                const extractor = new StructuredExtractor(client, oldStyleConfig, syncState);
-                allRecords = await extractor.extract(mapping, false, onProgress);
-            }
+        if (primaryConfig.extraction_mode === 'frontmatter') {
+            const extractor = new FrontmatterExtractor(client, extractorConfig);
+            allRecords = await extractor.extract(mapping, onProgress);
         }
         else {
-            // Old-format source
-            const mapping = { ...oldConfig.entity_mappings[0], target_repo: '_workspace_' };
-            const extractor = new StructuredExtractor(client, oldConfig, syncState);
+            const extractor = new StructuredExtractor(client, extractorConfig, syncState);
             allRecords = await extractor.extract(mapping, false, onProgress);
         }
-        log(`  Extracted ${allRecords.length} records (total)`);
+        log(`  Extracted ${allRecords.length} records`);
         // ── Write to each target ──────────────────────────────────────────────────
         for (const target of rule.targets) {
             const repoConfig = workspaceConfig.repos.find(r => r.name === target.repo);
@@ -248,41 +147,37 @@ export async function syncWorkspaceRule(options) {
                 schemaRegistry,
             });
             const existingSourceRefs = buildSourceRefIndex(graph);
-            // Apply target-specific filter
+            // Apply client-side filters (always per-target)
             let targetRecords = applyClientFilters(allRecords, target.filter, filterFieldDefs, log);
-            // Override target_repo on records before writing
             targetRecords = targetRecords.map(r => ({ ...r, target_repo: target.repo }));
             const targetResult = { repo: target.repo, created: 0, skipped: 0, derived: 0, errors: [] };
             const writeResults = await writeEntities(targetRecords, rule.source, graph, existingSourceRefs, log);
             targetResult.created += writeResults.created;
             targetResult.skipped += writeResults.skipped;
             targetResult.errors.push(...writeResults.errors);
-            // Derive secondary entities (if definition has derive_from configs)
-            if (definition) {
-                const primaryType = rule.entity_type ?? findPrimaryType(definition);
-                for (const [entityType, entityConfig] of Object.entries(definition.entities)) {
-                    if (entityType === primaryType || !entityConfig.derive_from)
-                        continue;
-                    log(`  Deriving ${entityType} entities for ${target.repo}...`);
-                    const derived = deriveEntities(targetRecords, entityType, entityConfig, rule.source);
-                    const existingDedupeValues = entityConfig.dedupe_field
-                        ? buildDedupeIndex(graph, entityType, entityConfig.dedupe_field)
-                        : new Map();
-                    const deduped = derived.filter(rec => {
-                        if (existingSourceRefs.has(rec.source_ref))
+            // Derive secondary entities
+            for (const [entityType, entityConfig] of Object.entries(definition.entities)) {
+                if (entityType === primaryType || !entityConfig.derive_from)
+                    continue;
+                log(`  Deriving ${entityType} entities for ${target.repo}...`);
+                const derived = deriveEntities(targetRecords, entityType, entityConfig, rule.source);
+                const existingDedupeValues = entityConfig.dedupe_field
+                    ? buildDedupeIndex(graph, entityType, entityConfig.dedupe_field)
+                    : new Map();
+                const deduped = derived.filter(rec => {
+                    if (existingSourceRefs.has(rec.source_ref))
+                        return false;
+                    if (entityConfig.dedupe_field) {
+                        const val = rec.frontmatter[entityConfig.dedupe_field];
+                        if (val && existingDedupeValues.has(String(val).toLowerCase()))
                             return false;
-                        if (entityConfig.dedupe_field) {
-                            const val = rec.frontmatter[entityConfig.dedupe_field];
-                            if (val && existingDedupeValues.has(String(val).toLowerCase()))
-                                return false;
-                        }
-                        return true;
-                    });
-                    const derivedResults = await writeEntities(deduped, rule.source, graph, existingSourceRefs, log);
-                    targetResult.derived += derivedResults.created;
-                    targetResult.skipped += derivedResults.skipped;
-                    targetResult.errors.push(...derivedResults.errors);
-                }
+                    }
+                    return true;
+                });
+                const derivedResults = await writeEntities(deduped, rule.source, graph, existingSourceRefs, log);
+                targetResult.derived += derivedResults.created;
+                targetResult.skipped += derivedResults.skipped;
+                targetResult.errors.push(...derivedResults.errors);
             }
             result.targets.push(targetResult);
         }
@@ -292,199 +187,70 @@ export async function syncWorkspaceRule(options) {
     }
     return result;
 }
-async function syncOneRule(options) {
-    const { workspacePath, repoConfig, rule, workspaceConfig, schemaExtensions, onProgress, userId, authService, serverUrl } = options;
-    const log = onProgress ?? (() => { });
-    const collectionName = repoConfig.name;
-    const configMgr = new SourceConfigManager(workspacePath);
-    const result = {
-        collection: collectionName,
-        source: rule.source,
-        created: 0,
-        skipped: 0,
-        derived: 0,
-        errors: [],
-    };
-    // Load source definition (try new format first, then old format)
-    const definition = configMgr.getDefinition(rule.source);
-    const oldConfig = !definition ? configMgr.get(rule.source) : null;
-    if (!definition && !oldConfig) {
-        throw new Error(`Source "${rule.source}" not found in .studiograph/sources/`);
+/** @deprecated Use syncSource() */
+export const syncWorkspaceRule = syncSource;
+/** Extract server-mode filter keys when there is exactly one target. */
+function computeServerFilter(targets, filterFieldDefs) {
+    if (targets.length !== 1 || !targets[0].filter)
+        return undefined;
+    const serverKeys = filterFieldDefs.filter(f => f.mode === 'server').map(f => f.key);
+    const out = {};
+    for (const key of serverKeys) {
+        if (key in targets[0].filter)
+            out[key] = targets[0].filter[key];
     }
-    // Resolve connector config
-    const connectorName = definition?.connector ?? oldConfig.connector;
-    const connectorConfigs = ConnectorManager.loadConfigs(workspacePath);
-    const connectorConfig = connectorConfigs.find(c => c.name === connectorName);
-    if (!connectorConfig) {
-        throw new Error(`Connector "${connectorName}" not configured. Run: studiograph connector add ${connectorName}`);
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * Run sync for a collection — both collection-level and workspace-level rules.
+ * Collection rules are converted to workspace-rule shape with a single target.
+ */
+export async function syncRepo(options) {
+    const { workspacePath, collectionName, workspaceConfig, schemaExtensions, onProgress, userId, authService, serverUrl } = options;
+    const log = onProgress ?? (() => { });
+    const results = [];
+    const syncOpts = { workspacePath, workspaceConfig, schemaExtensions, onProgress, userId, authService, serverUrl };
+    // Collection-level rules → synthetic workspace rules with single target
+    const repoConfig = workspaceConfig.repos.find(r => r.name === collectionName);
+    const collectionRules = repoConfig?.sync;
+    if (collectionRules && collectionRules.length > 0) {
+        for (const rule of collectionRules) {
+            log(`\nSyncing from source: ${rule.source}`);
+            try {
+                const wsRule = {
+                    source: rule.source,
+                    entity_type: rule.entity_type,
+                    targets: [{ repo: collectionName, filter: rule.filter }],
+                };
+                results.push(await syncSource({ ...syncOpts, rule: wsRule }));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`  Error: ${msg}`);
+                results.push({ source: rule.source, targets: [{ repo: collectionName, created: 0, skipped: 0, derived: 0, errors: [msg] }] });
+            }
+        }
     }
-    // Connect to source
-    const client = createDataFetcher(connectorConfig, definition, { userId, authService, serverUrl });
-    try {
-        log(`  Connecting to ${connectorName}${definition?.adapter === 'rest' ? ' (REST)' : ''}...`);
+    // Workspace-level rules that target this collection
+    const workspaceRules = workspaceConfig.sync ?? [];
+    for (const rule of workspaceRules) {
+        const matchingTargets = rule.targets.filter(t => t.repo === collectionName);
+        if (matchingTargets.length === 0)
+            continue;
+        log(`\nSyncing workspace rule: ${rule.source} → ${collectionName}`);
         try {
-            await client.connect();
+            results.push(await syncSource({ ...syncOpts, rule: { ...rule, targets: matchingTargets } }));
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`Failed to connect to connector "${connectorName}" at ${connectorConfig.url}. (${msg})`);
-        }
-        log(`  Available tools: ${client.getTools().map(t => t.name).join(', ')}`);
-        // Build graph manager for the collection
-        const repoPath = join(workspacePath, repoConfig.path);
-        if (!existsSync(repoPath)) {
-            throw new Error(`Collection path does not exist: ${repoPath}`);
-        }
-        const schemaRegistry = new SchemaRegistry(schemaExtensions);
-        const graph = new BaseGraphManager({
-            repoPath,
-            repoName: collectionName,
-            gitUser: { id: 'sync', name: 'Studiograph Sync', email: 'sync@studiograph.local' },
-            schemaRegistry,
-        });
-        // Build index of existing source_refs in this collection
-        const existingSourceRefs = buildSourceRefIndex(graph);
-        log(`  ${existingSourceRefs.size} existing synced entities in collection`);
-        if (definition) {
-            // ── New-format source definition ──
-            await syncNewFormat({
-                definition,
-                sourceName: rule.source,
-                rule,
-                graph,
-                collectionName,
-                client,
-                existingSourceRefs,
-                schemaRegistry,
-                workspacePath,
-                schemaExtensions,
-                result,
-                onProgress,
-            });
-        }
-        else {
-            // ── Old-format source config (backwards compatibility) ──
-            await syncOldFormat({
-                config: oldConfig,
-                rule,
-                graph,
-                collectionName,
-                client,
-                existingSourceRefs,
-                schemaRegistry,
-                workspacePath,
-                schemaExtensions,
-                result,
-                onProgress,
-            });
+            log(`  Error: ${msg}`);
+            results.push({ source: rule.source, targets: matchingTargets.map(t => ({ repo: t.repo, created: 0, skipped: 0, derived: 0, errors: [msg] })) });
         }
     }
-    finally {
-        await client.close();
-    }
-    return result;
-}
-async function syncNewFormat(options) {
-    const { definition, sourceName, rule, graph, collectionName, client, existingSourceRefs, schemaRegistry, workspacePath, schemaExtensions, result, onProgress } = options;
-    const log = onProgress ?? (() => { });
-    // Find primary entity config
-    const primaryType = rule.entity_type ?? findPrimaryType(definition);
-    const primaryConfig = definition.entities[primaryType];
-    if (!primaryConfig) {
-        throw new Error(`Entity type "${primaryType}" not found in source definition`);
-    }
-    // Convert to EntityMapping for the extractor
-    const mapping = sourceEntityConfigToMapping(primaryType, primaryConfig, sourceName, collectionName, rule.filter);
-    // Extract records
-    const syncState = new SyncStateManager(workspacePath);
-    const oldStyleConfig = {
-        name: sourceName,
-        connector: definition.connector,
-        enabled: true,
-        added_at: new Date().toISOString(),
-        entity_mappings: [mapping],
-    };
-    log(`  Extracting ${primaryType} records...`);
-    let records;
-    if (primaryConfig.extraction_mode === 'frontmatter') {
-        const extractor = new FrontmatterExtractor(client, oldStyleConfig);
-        records = await extractor.extract(mapping, onProgress);
-    }
-    else {
-        const extractor = new StructuredExtractor(client, oldStyleConfig, syncState);
-        records = await extractor.extract(mapping, false, onProgress);
-    }
-    log(`  Extracted ${records.length} records`);
-    // Apply client-side filters declared by the source definition
-    records = applyClientFilters(records, rule.filter, definition.filter_fields ?? [], log);
-    // Write primary entities
-    log(`  Writing ${records.length} records...`);
-    const writeResults = await writeEntities(records, sourceName, graph, existingSourceRefs, log);
-    result.created += writeResults.created;
-    result.skipped += writeResults.skipped;
-    result.errors.push(...writeResults.errors);
-    // Derive secondary entities
-    for (const [entityType, entityConfig] of Object.entries(definition.entities)) {
-        if (entityType === primaryType || !entityConfig.derive_from)
-            continue;
-        log(`  Deriving ${entityType} entities...`);
-        const derived = deriveEntities(records, entityType, entityConfig, sourceName);
-        log(`  Found ${derived.length} ${entityType} candidates`);
-        // Dedup derived entities against existing collection
-        const existingDedupeValues = entityConfig.dedupe_field
-            ? buildDedupeIndex(graph, entityType, entityConfig.dedupe_field)
-            : new Map();
-        const dedupedDerived = derived.filter(rec => {
-            // Skip if source_ref already exists
-            if (existingSourceRefs.has(rec.source_ref))
-                return false;
-            // Skip if dedupe field matches existing entity
-            if (entityConfig.dedupe_field) {
-                const dedupeVal = rec.frontmatter[entityConfig.dedupe_field];
-                if (dedupeVal && existingDedupeValues.has(String(dedupeVal).toLowerCase()))
-                    return false;
-            }
-            return true;
-        });
-        const derivedResults = await writeEntities(dedupedDerived, sourceName, graph, existingSourceRefs, log);
-        result.derived += derivedResults.created;
-        result.skipped += derivedResults.skipped;
-        result.errors.push(...derivedResults.errors);
-    }
-}
-async function syncOldFormat(options) {
-    const { config, rule, graph, collectionName, client, existingSourceRefs, schemaRegistry, workspacePath, result, onProgress } = options;
-    const log = onProgress ?? (() => { });
-    const syncState = new SyncStateManager(workspacePath);
-    for (const mapping of config.entity_mappings) {
-        // Override target_repo to write to this collection
-        const adjustedMapping = { ...mapping, target_repo: collectionName };
-        // Merge rule filter into list_params
-        if (rule.filter) {
-            const existing = adjustedMapping.list_params ?? {};
-            adjustedMapping.list_params = Array.isArray(existing)
-                ? existing.map(p => ({ ...p, ...rule.filter }))
-                : { ...existing, ...rule.filter };
-        }
-        log(`  Extracting ${mapping.entity_type} from ${mapping.source_type}...`);
-        let records;
-        if (adjustedMapping.extraction_mode === 'frontmatter') {
-            const extractor = new FrontmatterExtractor(client, config);
-            records = await extractor.extract(adjustedMapping, onProgress);
-        }
-        else {
-            const extractor = new StructuredExtractor(client, config, syncState);
-            records = await extractor.extract(adjustedMapping, false, onProgress);
-        }
-        log(`  Extracted ${records.length} records`);
-        // Apply client-side filters declared by the connector's source template
-        const templateDef = SOURCE_DEFINITIONS[config.connector];
-        records = applyClientFilters(records, rule.filter, templateDef?.filter_fields ?? [], log);
-        const writeResults = await writeEntities(records, config.name, graph, existingSourceRefs, log);
-        result.created += writeResults.created;
-        result.skipped += writeResults.skipped;
-        result.errors.push(...writeResults.errors);
+    if (results.length === 0) {
+        throw new Error(`Collection "${collectionName}" has no sync rules configured`);
     }
+    return { results };
 }
 async function writeEntities(records, sourceName, graph, existingSourceRefs, log) {
     const results = { created: 0, skipped: 0, errors: [] };