@treeseed/sdk 0.8.12 → 0.8.14

package/dist/seeds/normalize.js

@@ -0,0 +1,275 @@
+function declaredEnvironments(resource, manifest) {
+  return resource.environments && resource.environments.length > 0 ? resource.environments : manifest.environments;
+}
+function selectedEnvironments(resource, manifest, selected) {
+  return declaredEnvironments(resource, manifest).filter((environment) => selected.includes(environment));
+}
+function ownership(seed, resourceKey) {
+  return {
+    seed: {
+      name: seed.name,
+      resourceKey,
+      version: seed.version
+    }
+  };
+}
+function seedOwnershipMetadata(seed, resourceKey) {
+  return ownership(seed, resourceKey);
+}
+function withMetadata(seed, resourceKey, metadata) {
+  return {
+    ...metadata ?? {},
+    ...ownership(seed, resourceKey)
+  };
+}
+function providerLaneEnvironments(provider, lane, manifest) {
+  const providerEnvironments = declaredEnvironments(provider, manifest);
+  const laneEnvironments = lane.environments && lane.environments.length > 0 ? lane.environments : providerEnvironments;
+  return laneEnvironments.filter((environment) => providerEnvironments.includes(environment));
+}
+function normalizeSeedResources(manifest, selected) {
+  const resources = [];
+  for (const team of manifest.resources.teams) {
+    resources.push({
+      kind: "team",
+      key: team.key,
+      label: team.displayName ?? team.name ?? team.slug,
+      environments: selectedEnvironments(team, manifest, selected),
+      payload: {
+        slug: team.slug,
+        name: team.name ?? team.slug,
+        displayName: team.displayName ?? team.name ?? team.slug,
+        logoUrl: team.logoUrl ?? null,
+        profileSummary: team.profileSummary ?? null,
+        metadata: withMetadata(manifest, team.key, team.metadata)
+      }
+    });
+  }
+  for (const host of manifest.resources.repositoryHosts) {
+    resources.push({
+      kind: "repositoryHost",
+      key: host.key,
+      label: `${host.provider}/${host.name}`,
+      environments: selectedEnvironments(host, manifest, selected),
+      payload: {
+        teamKey: host.team,
+        provider: host.provider,
+        name: host.name,
+        ownership: host.ownership ?? "treeseed_managed",
+        accountLabel: host.accountLabel ?? null,
+        organizationOrOwner: host.organizationOrOwner,
+        defaultVisibility: host.defaultVisibility ?? "private",
+        softwareRepositoryNameTemplate: host.softwareRepositoryNameTemplate ?? null,
+        contentRepositoryNameTemplate: host.contentRepositoryNameTemplate ?? null,
+        branchPolicy: host.branchPolicy ?? null,
+        workflowPolicy: host.workflowPolicy ?? null,
+        allowedProjectKinds: host.allowedProjectKinds ?? null,
+        status: host.status ?? "active",
+        credentialRef: host.credentialRef ?? null,
+        metadata: withMetadata(manifest, host.key, host.metadata)
+      }
+    });
+  }
+  for (const project of manifest.resources.projects) {
+    resources.push({
+      kind: "project",
+      key: project.key,
+      label: `${project.team.replace(/^team:/u, "")}/${project.slug}`,
+      environments: selectedEnvironments(project, manifest, selected),
+      payload: {
+        teamKey: project.team,
+        slug: project.slug,
+        name: project.name,
+        description: project.description ?? null,
+        kind: project.kind ?? null,
+        repository: project.repository,
+        metadata: withMetadata(manifest, project.key, project.metadata)
+      }
+    });
+  }
+  for (const repository of manifest.resources.hubRepositories) {
+    resources.push({
+      kind: "hubRepository",
+      key: repository.key,
+      label: `${repository.project.replace(/^project:/u, "")}/${repository.role}`,
+      environments: selectedEnvironments(repository, manifest, selected),
+      payload: {
+        projectKey: repository.project,
+        repositoryHostKey: repository.repositoryHost ?? null,
+        role: repository.role,
+        provider: repository.provider,
+        owner: repository.owner,
+        name: repository.name,
+        gitUrl: repository.gitUrl,
+        defaultBranch: repository.defaultBranch ?? null,
+        currentBranch: repository.currentBranch ?? repository.defaultBranch ?? null,
+        submodulePath: repository.submodulePath ?? null,
+        status: repository.status ?? "active",
+        accessPolicy: repository.accessPolicy ?? null,
+        releasePolicy: repository.releasePolicy ?? null,
+        publishPolicy: repository.publishPolicy ?? null,
+        metadata: withMetadata(manifest, repository.key, repository.metadata)
+      }
+    });
+  }
+  for (const provider of manifest.resources.capacityProviders) {
+    resources.push({
+      kind: "capacityProvider",
+      key: provider.key,
+      label: provider.name,
+      environments: selectedEnvironments(provider, manifest, selected),
+      payload: {
+        teamKey: provider.team,
+        name: provider.name,
+        kind: provider.kind ?? null,
+        provider: provider.provider,
+        billingScope: provider.billingScope ?? null,
+        monthlyCreditBudget: provider.monthlyCreditBudget ?? null,
+        dailyCreditBudget: provider.dailyCreditBudget ?? null,
+        maxConcurrentWorkdays: provider.maxConcurrentWorkdays ?? null,
+        maxConcurrentWorkers: provider.maxConcurrentWorkers ?? null,
+        capacityModel: provider.capacityModel ?? null,
+        registration: provider.registration ?? null,
+        metadata: withMetadata(manifest, provider.key, provider.metadata)
+      }
+    });
+    for (const lane of provider.lanes ?? []) {
+      resources.push({
+        kind: "capacityLane",
+        key: lane.key,
+        label: lane.name,
+        parentKey: provider.key,
+        environments: providerLaneEnvironments(provider, lane, manifest).filter((environment) => selected.includes(environment)),
+        payload: {
+          providerKey: provider.key,
+          name: lane.name,
+          businessModel: lane.businessModel ?? null,
+          modelFamily: lane.modelFamily ?? null,
+          modelClass: lane.modelClass ?? null,
+          regionPolicy: lane.regionPolicy ?? null,
+          unit: lane.unit ?? null,
+          scarcityLevel: lane.scarcityLevel ?? null,
+          hardLimits: lane.hardLimits ?? null,
+          routingPolicy: lane.routingPolicy ?? null,
+          metadata: withMetadata(manifest, lane.key, lane.metadata)
+        }
+      });
+    }
+  }
+  for (const grant of manifest.resources.capacityGrants) {
+    resources.push({
+      kind: "capacityGrant",
+      key: grant.key,
+      label: `${grant.provider.replace(/^capacity-provider:/u, "")} -> ${grant.project?.replace(/^project:/u, "") ?? grant.team.replace(/^team:/u, "")}`,
+      environments: selectedEnvironments(grant, manifest, selected),
+      payload: {
+        providerKey: grant.provider,
+        laneKey: grant.lane ?? null,
+        teamKey: grant.team,
+        projectKey: grant.project ?? null,
+        environment: grant.environment ?? null,
+        grantScope: grant.grantScope ?? null,
+        dailyCreditLimit: grant.dailyCreditLimit ?? null,
+        weeklyCreditLimit: grant.weeklyCreditLimit ?? null,
+        monthlyCreditLimit: grant.monthlyCreditLimit ?? null,
+        dailyUsdLimit: grant.dailyUsdLimit ?? null,
+        weeklyQuotaMinutes: grant.weeklyQuotaMinutes ?? null,
+        monthlyProviderUnits: grant.monthlyProviderUnits ?? null,
+        priorityWeight: grant.priorityWeight ?? null,
+        overflowPolicy: grant.overflowPolicy ?? null,
+        state: grant.state ?? null,
+        metadata: withMetadata(manifest, grant.key, grant.metadata)
+      }
+    });
+  }
+  for (const policy of manifest.resources.workPolicies) {
+    resources.push({
+      kind: "workPolicy",
+      key: policy.key,
+      label: `${policy.project.replace(/^project:[^/]+\//u, "")}/${policy.environment}`,
+      environments: selectedEnvironments(policy, manifest, selected),
+      payload: {
+        projectKey: policy.project,
+        environment: policy.environment,
+        enabled: policy.enabled ?? true,
+        startCron: policy.startCron ?? "0 9 * * 1-5",
+        durationMinutes: policy.durationMinutes ?? 480,
+        maxRunners: policy.maxRunners ?? 1,
+        maxWorkersPerRunner: policy.maxWorkersPerRunner ?? 4,
+        dailyCreditBudget: policy.dailyCreditBudget ?? null,
+        maxQueuedTasks: policy.maxQueuedTasks ?? null,
+        maxQueuedCredits: policy.maxQueuedCredits ?? null,
+        autoscale: policy.autoscale ?? null,
+        creditWeights: policy.creditWeights ?? null,
+        metadata: withMetadata(manifest, policy.key, policy.metadata)
+      }
+    });
+  }
+  for (const product of manifest.resources.products) {
+    resources.push({
+      kind: "product",
+      key: product.key,
+      label: `${product.kind}/${product.slug}`,
+      environments: selectedEnvironments(product, manifest, selected),
+      payload: {
+        teamKey: product.team,
+        kind: product.kind,
+        slug: product.slug,
+        title: product.title,
+        summary: product.summary ?? null,
+        visibility: product.visibility ?? "private",
+        listingEnabled: product.listingEnabled ?? false,
+        offerMode: product.offerMode ?? "private",
+        manifestKey: product.manifestKey ?? null,
+        artifactKey: product.artifactKey ?? null,
+        searchText: product.searchText ?? null,
+        metadata: withMetadata(manifest, product.key, product.metadata)
+      }
+    });
+  }
+  for (const artifact of manifest.resources.catalogArtifacts) {
+    resources.push({
+      kind: "catalogArtifact",
+      key: artifact.key,
+      label: `${artifact.product.replace(/^product:/u, "")}@${artifact.version}`,
+      environments: selectedEnvironments(artifact, manifest, selected),
+      payload: {
+        productKey: artifact.product,
+        version: artifact.version,
+        kind: artifact.kind,
+        contentKey: artifact.contentKey,
+        manifestKey: artifact.manifestKey ?? null,
+        publishedAt: artifact.publishedAt ?? null,
+        metadata: withMetadata(manifest, artifact.key, artifact.metadata)
+      }
+    });
+  }
+  return resources;
+}
+function resolveSelectedSeedEnvironments(manifest, requested) {
+  const errors = [];
+  const raw = requested ? requested.split(",").map((entry) => entry.trim()).filter(Boolean) : manifest.defaultEnvironments && manifest.defaultEnvironments.length > 0 ? manifest.defaultEnvironments : ["local"];
+  const environments = [];
+  for (const environment of raw) {
+    if (!["local", "staging", "prod"].includes(environment)) {
+      errors.push(`Unknown seed environment: ${environment}.`);
+      continue;
+    }
+    if (!manifest.environments.includes(environment)) {
+      errors.push(`Seed ${manifest.name} does not declare environment: ${environment}.`);
+      continue;
+    }
+    if (!environments.includes(environment)) {
+      environments.push(environment);
+    }
+  }
+  if (environments.length === 0 && errors.length === 0) {
+    errors.push("No seed environments selected.");
+  }
+  return { environments, errors };
+}
+export {
+  normalizeSeedResources,
+  resolveSelectedSeedEnvironments,
+  seedOwnershipMetadata
+};

package/dist/seeds/planner.d.ts

@@ -0,0 +1,10 @@
+import type { SeedCurrentResource, SeedDiagnostic, SeedEnvironment, SeedManifest, SeedPlan } from './types.js';
+export declare function createSeedPlan(input: {
+    manifest: SeedManifest;
+    manifestPath: string;
+    environments: SeedEnvironment[];
+    mode: SeedPlan['mode'];
+    diagnostics?: SeedDiagnostic[];
+    currentResources?: SeedCurrentResource[];
+}): SeedPlan;
+export declare function formatSeedPlan(plan: SeedPlan): string[];

package/dist/seeds/planner.js

@@ -0,0 +1,111 @@
+import { normalizeSeedResources } from "./normalize.js";
+const ACTION_TYPES = ["create", "update", "unchanged", "skip", "delete", "error"];
+function emptySummary() {
+  return {
+    create: 0,
+    update: 0,
+    unchanged: 0,
+    skip: 0,
+    delete: 0,
+    error: 0
+  };
+}
+function stableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJson).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function toAction(resource, currentByKey) {
+  if (resource.environments.length === 0) {
+    return {
+      ...resource,
+      action: "skip",
+      reason: "Resource does not target the selected environments."
+    };
+  }
+  const current = currentByKey.get(resource.key);
+  if (current) {
+    return {
+      ...resource,
+      action: stableJson(resource.payload) === stableJson(current.payload) ? "unchanged" : "update",
+      existing: current.existing ?? null
+    };
+  }
+  return {
+    ...resource,
+    action: "create"
+  };
+}
+function createSeedPlan(input) {
+  const currentByKey = new Map((input.currentResources ?? []).map((resource) => [resource.key, resource]));
+  const actions = normalizeSeedResources(input.manifest, input.environments).map((resource) => toAction(resource, currentByKey));
+  const summary = emptySummary();
+  for (const action of actions) {
+    summary[action.action] += 1;
+  }
+  for (const actionType of ACTION_TYPES) {
+    summary[actionType] += 0;
+  }
+  return {
+    ok: summary.error === 0 && !(input.diagnostics ?? []).some((diagnostic) => diagnostic.severity === "error"),
+    seed: input.manifest.name,
+    version: input.manifest.version,
+    mode: input.mode,
+    environments: input.environments,
+    summary,
+    actions,
+    diagnostics: input.diagnostics ?? [],
+    manifestPath: input.manifestPath
+  };
+}
+function actionKindLabel(action) {
+  switch (action.kind) {
+    case "repositoryHost":
+      return "repository host";
+    case "hubRepository":
+      return "hub repository";
+    case "capacityProvider":
+      return "capacity provider";
+    case "capacityLane":
+      return "lane";
+    case "capacityGrant":
+      return "grant";
+    case "workPolicy":
+      return "work policy";
+    case "catalogArtifact":
+      return "catalog artifact";
+    default:
+      return action.kind;
+  }
+}
+function formatSeedPlan(plan) {
+  const lines = [
+    `Seed: ${plan.seed}`,
+    `Environments: ${plan.environments.join(", ")}`,
+    ""
+  ];
+  for (const action of plan.actions) {
+    if (action.action === "skip") continue;
+    lines.push(`${action.action.toUpperCase()} ${actionKindLabel(action)} ${action.label}`);
+  }
+  if (lines[lines.length - 1] !== "") {
+    lines.push("");
+  }
+  lines.push(
+    "Summary:",
+    `  create: ${plan.summary.create}`,
+    `  update: ${plan.summary.update}`,
+    `  unchanged: ${plan.summary.unchanged}`,
+    `  skipped: ${plan.summary.skip}`,
+    `  errors: ${plan.summary.error}`
+  );
+  return lines;
+}
+export {
+  createSeedPlan,
+  formatSeedPlan
+};

package/dist/seeds/schema.d.ts

@@ -0,0 +1,2 @@
+import { type SeedDiagnostic, type SeedManifest } from './types.js';
+export declare function parseSeedManifest(value: unknown, diagnostics: SeedDiagnostic[]): SeedManifest | null;