Function syncProvider

packages/core/src/sync/index.ts:128–335

(
  provider: SyncProvider<SourceModel>,
  options: SyncOptions = {},
)

}

export async function syncProvider<SourceModel>(
  provider: SyncProvider<SourceModel>,
  options: SyncOptions = {},
): Promise<SyncResult> {
  console.log(`\nSyncing ${provider.name}...`);

  const existingState = await readExisting(provider.modelsDir);
  const { models: existing, brokenSymlinks } = existingState;
  let { modelMetadata } = existingState;
  const sourceModels = provider.parseModels(await provider.fetchModels());
  const desired = new Map<string, { model: z.infer<typeof SyncedAuthoredModel>; content: string }>();
  const desiredMetadata = new Map<string, { model: z.infer<typeof ModelMetadata>; content: string }>();
  const skippedRemote: string[] = [];

  for (const sourceModel of sourceModels) {
    const translated = provider.translateModel(sourceModel, {
      existing(id) {
        return existing.get(`${id}.toml`)?.toml;
      },
      authored(id) {
        return existing.get(`${id}.toml`)?.authored;
      },
    });
    if (translated === undefined) {
      if (provider.sourceID !== undefined) skippedRemote.push(provider.sourceID(sourceModel));
      continue;
    }

    const relativePath = `${translated.id}.toml`;
    if (provider.skipCreates && !existing.has(relativePath)) {
      skippedRemote.push(translated.id);
      continue;
    }

    if (desired.has(relativePath)) {
      throw new Error(`Duplicate synced model path: ${provider.id}/${relativePath}`);
    }

    if (translated.metadata !== undefined) {
      const parsedMetadata = ModelMetadata.safeParse({
        id: translated.metadata.id,
        ...stripUndefined(translated.metadata.model),
      });
      if (!parsedMetadata.success) {
        parsedMetadata.error.cause = { provider: provider.id, metadata: translated.metadata.id };
        throw parsedMetadata.error;
      }
      const metadataPath = `${translated.metadata.id}.toml`;
      if (desiredMetadata.has(metadataPath)) throw new Error(`Duplicate synced metadata path: ${metadataPath}`);
      desiredMetadata.set(metadataPath, {
        model: parsedMetadata.data,
        content: formatMetadataToml(parsedMetadata.data),
      });
    }

    const translatedModel = provider.preserveBaseModels === false
      ? translated.model
      : preserveBaseModel(translated.model, existing.get(relativePath)?.authored);