sailfork / t3code-github / .repos/ alchemy-effect/ packages/ railway/ src/ Template.ts

import { Query, type UnwrapPlan } from "@distilled.cloud/core/query";
import {
  Railway,
  type Project as RailwayProject,
  type Service as RailwayService,
  type Template as RailwayTemplate,
  type TemplateDeployV2Input,
} from "@distilled.cloud/railway";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import { RailwayEnvironment } from "./Environment.ts";
import { projectServices as fetchProjectServices } from "./GraphQL.ts";
import { createRailwayName, matchesAlchemyPhysicalName } from "./Metadata.ts";
import {
  createProject,
  environmentIdOf as projectEnvironmentId,
  ownedProjects,
  workspaceIdOf as projectWorkspaceId,
} from "./Project.ts";
import type { Providers } from "./Providers.ts";

const templateFields = <E>(template: Query<RailwayTemplate, E>) => ({
  id: template.id,
  code: template.code,
  name: template.name,
  serializedConfig: template.serializedConfig,
});
const templateSummaryFields = <E>(template: Query<RailwayTemplate, E>) => ({
  id: template.id,
  code: template.code,
  name: template.name,
});
const projectFields = <E>(project: Query<RailwayProject, E>) => ({
  id: project.id,
  name: project.name,
  description: project.description,
  workspaceId: project.workspaceId,
  primaryEnvironmentId: project.primaryEnvironmentId,
  baseEnvironmentId: project.baseEnvironmentId,
  deletedAt: project.deletedAt,
});
const serviceFields = <E>(service: Query<RailwayService, E>) => ({
  id: service.id,
  name: service.name,
  deletedAt: service.deletedAt,
  templateId: service.templateId,
});
type CloudTemplate = UnwrapPlan<ReturnType<typeof templateFields>>;
type CloudProject = UnwrapPlan<ReturnType<typeof projectFields>>;
type CloudService = UnwrapPlan<ReturnType<typeof serviceFields>>;

/**
 * A resource-valued prop: the resource itself, or an Effect that produces
 * it (so `yield* Project(...)` and `Project(...)` both type-check).
 */
type Ref<T> = T | Effect.Effect<T, never, Providers>;

/**
 * Project identity a template deploys into. Accepts a `Railway.Project`
 * or a `{ projectId }` stub.
 */
export type TemplateProject = {
  readonly projectId: string;
  readonly environmentId?: string;
  readonly workspaceId?: string;
};

/**
 * Environment identity a template deploys into. Accepts a
 * `Railway.Project` (its primary environment), a `Railway.Environment`,
 * or an `{ environmentId }` stub.
 */
export type TemplateEnvironment = { readonly environmentId: string };

export interface TemplateProps {
  /**
   * Marketplace template id (UUID) or template code (`postgres`,
   * `redis`). Changing it replaces the deployment.
   */
  templateId: string;
  /**
   * Project to deploy into. Accepts a `Railway.Project` or an Effect
   * that produces one. If omitted, Alchemy creates an owned Project
   * (serialized `createProject`) and deploys into it. Changing it
   * replaces the deployment.
   */
  project?: Ref<TemplateProject>;
  /**
   * Environment to deploy into. Accepts a `Railway.Project` (primary
   * environment), a `Railway.Environment`, or `{ environmentId }`.
   * Defaults to the project's primary environment. Changing it
   * replaces the deployment.
   */
  environment?: Ref<TemplateEnvironment>;
  /**
   * Serialized template config passed to `templateDeployV2`. If omitted,
   * Alchemy fetches it from the marketplace template. Variables without
   * a `value` are filled from `defaultValue`.
   */
  serializedConfig?: unknown;
}

export type Template = Resource<
  "Railway.Template",
  TemplateProps,
  {
    /** Canonical marketplace template id (UUID). */
    templateId: string;
    /** Marketplace template code (`postgres`, …), when its metadata is accessible. */
    code: string | undefined;
    /** Marketplace template display name, when its metadata is accessible. */
    name: string | undefined;
    /** Project the template was deployed into. */
    projectId: string;
    /** Environment the template was deployed into. */
    environmentId: string;
    /** Workspace the project lives in. */
    workspaceId: string;
    /** Latest `templateDeployV2` workflow id, if Railway returned one. */
    workflowId: string | undefined;
    /** Service ids created from the template. */
    serviceIds: string[];
    /**
     * True when Alchemy created the Project because `project` was
     * omitted. Delete then removes that Project.
     */
    ownsProject: boolean;
    /** Dashboard URL (`https://railway.com/project/{projectId}`). */
    url: string;
  },
  never,
  Providers
>;

const resolveTemplateProps = (
  props: TemplateProps | Effect.Effect<TemplateProps, never, Providers>,
): Effect.Effect<TemplateProps, never, Providers> =>
  Effect.gen(function* () {
    const resolved = Effect.isEffect(props) ? yield* props : props;
    if (globalThis.__ALCHEMY_RUNTIME__) return resolved;
    const project =
      resolved.project === undefined
        ? undefined
        : Effect.isEffect(resolved.project)
          ? yield* resolved.project as Effect.Effect<TemplateProject, never, Providers>
          : resolved.project;
    const environment =
      resolved.environment === undefined
        ? undefined
        : Effect.isEffect(resolved.environment)
          ? yield* resolved.environment as Effect.Effect<TemplateEnvironment, never, Providers>
          : resolved.environment;
    return { ...resolved, project, environment };
  });

const TemplateResource = Resource<Template>("Railway.Template");

/**
 * A Railway.Template deploys a marketplace template into a Project.
 * Alchemy looks up the template (`template` / `templates`), sends
 * `templateDeployV2` with its `serializedConfig`, and adopts the
 * project/services the workflow creates.
 *
 * Pass a Project to deploy into an existing one. Omit `project` and
 * Alchemy creates an owned Project first (the workspace project-create
 * cap is serialized).
 *
 * @see https://docs.railway.com/templates/deploy
 *
 * ### Deploy a marketplace template
 * `templateId` is a marketplace UUID or code (`postgres`). Pass a
 * Project to deploy into it.
 *
 * **Example:** Postgres into a Project
 * ```typescript
 * const site = yield* Railway.Project("Site");
 * const db = yield* Railway.Template("Postgres", {
 *   templateId: "postgres",
 *   project: site,
 * });
 * ```
 *
 * :::caution[Changing `templateId`, `project`, or `environment` replaces]
 * The previous template services (and the owned Project, if Alchemy
 * created it) are deleted. A new deploy runs.
 * :::
 *
 * ### Create the Project
 * Omit `project` to let Alchemy create one. The name is stamped so
 * nuke can reclaim it.
 *
 * **Example:** Generated Project
 * ```typescript
 * const db = yield* Railway.Template("Postgres", {
 *   templateId: "postgres",
 * });
 * ```
 *
 * ### Serialized config
 * Omit `serializedConfig` to use the marketplace default. Pass a
 * config (from `template.serializedConfig`, with service variable
 * `value`s filled in) to override.
 *
 * **Example:** Override config
 * ```typescript
 * const db = yield* Railway.Template("Postgres", {
 *   templateId: "postgres",
 *   project: site,
 *   serializedConfig: config,
 * });
 * ```
 *
 * ### Environment
 * Defaults to the Project's primary environment.
 *
 * **Example:** Extra environment
 * ```typescript
 * const staging = yield* Railway.Environment("Staging", { project: site });
 * const db = yield* Railway.Template("StagingPostgres", {
 *   templateId: "postgres",
 *   project: site,
 *   environment: staging,
 * });
 * ```
 *
 * ### Module-scope declarations
 * Resource-valued props accept the resource or an Effect producing it.
 *
 * **Example:** Module-scope Template
 * ```typescript
 * // src/db.ts
 * import * as Railway from "@alchemy.run/railway";
 *
 * export const Site = Railway.Project("Site");
 * export const Postgres = Railway.Template("Postgres", {
 *   templateId: "postgres",
 *   project: Site,
 * });
 * ```
 *
 * @resource
 * @product Project
 */
export const Template: typeof TemplateResource = Object.assign(
  (id: string, props: TemplateProps | Effect.Effect<TemplateProps, never, Providers>) =>
    TemplateResource(id, resolveTemplateProps(props)),
  TemplateResource,
);

export class TemplateNotFound extends Data.TaggedError("Railway.TemplateNotFound")<{
  templateId: string;
}> {}

export class TemplateNotCreated extends Data.TaggedError("Railway.TemplateNotCreated")<{
  templateId: string;
  projectId: string;
}> {}

export class TemplateConfigRequired extends Data.TaggedError("Railway.TemplateConfigRequired")<{
  templateId: string;
}> {}

export class TemplateWorkflowFailed extends Data.TaggedError("Railway.TemplateWorkflowFailed")<{
  workflowId: string;
  error: string;
}> {}

class TemplatePending extends Data.TaggedError("Railway.TemplatePending")<{
  projectId: string;
  state: string;
}> {}

const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

const projectIdOf = (value: unknown): string | undefined => {
  if (value === null || typeof value !== "object") return undefined;
  const rec = value as { projectId?: unknown };
  return typeof rec.projectId === "string" && rec.projectId.length > 0 ? rec.projectId : undefined;
};

const environmentIdOf = (value: unknown): string | undefined => {
  if (value === null || typeof value !== "object") return undefined;
  const rec = value as { environmentId?: unknown };
  return typeof rec.environmentId === "string" && rec.environmentId.length > 0
    ? rec.environmentId
    : undefined;
};

const workspaceIdOf = (value: unknown): string | undefined => {
  if (value === null || typeof value !== "object") return undefined;
  const rec = value as { workspaceId?: unknown };
  return typeof rec.workspaceId === "string" && rec.workspaceId.length > 0
    ? rec.workspaceId
    : undefined;
};

const isRecord = (value: unknown): value is Record<string, unknown> =>
  value !== null && typeof value === "object" && !Array.isArray(value);

const isGoneProject = (project: CloudProject | undefined) =>
  project === undefined || project.deletedAt != null;

const isGoneService = (service: CloudService | undefined) =>
  service === undefined || service.deletedAt != null;

const currentWorkspaceId = Effect.fn(function* () {
  const env = yield* yield* RailwayEnvironment;
  return env.workspaceId;
});

const environmentIdFromProject = (project: CloudProject) => projectEnvironmentId(project);

const toAttrs = (input: {
  template: { id: string; code?: string; name?: string };
  project: CloudProject;
  environmentId: string;
  workspaceId: string;
  serviceIds: string[];
  workflowId: string | undefined;
  ownsProject: boolean;
}): Template["Attributes"] => ({
  templateId: input.template.id,
  code: input.template.code,
  name: input.template.name,
  projectId: input.project.id,
  environmentId: input.environmentId,
  workspaceId: input.workspaceId || projectWorkspaceId(input.project) || "",
  workflowId: input.workflowId,
  serviceIds: input.serviceIds,
  ownsProject: input.ownsProject,
  url: `https://railway.com/project/${input.project.id}`,
});

const readProject = Query.fn((id: string) => projectFields(Railway.project({ id })));

const getProject = (projectId: string) =>
  readProject(projectId).pipe(
    Effect.map((project) => (isGoneProject(project) ? undefined : project)),
    Effect.catchTag("RailwayNotFound", () => Effect.undefined),
  );

const readTemplateById = Query.fn((id: string) => templateFields(Railway.template({ id })));

const readTemplateByCode = Query.fn((code: string) => templateFields(Railway.template({ code })));

const readTemplateSummary = Query.fn((id: string) =>
  templateSummaryFields(Railway.template({ id })),
);

const getTemplateById = (id: string) =>
  readTemplateById(id).pipe(Effect.map((template): CloudTemplate | undefined => template));

const getTemplateByCode = (code: string) =>
  readTemplateByCode(code).pipe(Effect.map((template): CloudTemplate | undefined => template));

const findPublished = (needle: string) =>
  Query.items(
    Railway.templates({ first: 50 }).pipe(
      Query.map((template) => ({ id: template.id, code: template.code })),
    ),
  ).pipe(
    Stream.filter((template) => template.id === needle || template.code === needle),
    Stream.take(1),
    Stream.runHead,
    Effect.flatMap((option) =>
      option._tag === "Some" ? getTemplateByCode(option.value.code) : Effect.undefined,
    ),
  );

const resolveMarketplaceTemplate = (templateId: string) =>
  Effect.gen(function* () {
    const primary = UUID.test(templateId)
      ? yield* getTemplateById(templateId).pipe(
          Effect.catchTag("RailwayForbidden", (failure) =>
            findPublished(templateId).pipe(
              Effect.flatMap((template) =>
                template === undefined ? Effect.fail(failure) : Effect.succeed(template),
              ),
            ),
          ),
        )
      : yield* getTemplateByCode(templateId);
    if (primary != null) return primary;
    const secondary = UUID.test(templateId)
      ? yield* getTemplateByCode(templateId)
      : yield* getTemplateById(templateId);
    if (secondary != null) return secondary;
    return yield* findPublished(templateId);
  });

const readSourceForProject = Query.fn((projectId: string) =>
  Railway.templateSourceForProject({ projectId }).pipe(
    Query.map((source) => ({ id: source.id, code: source.code, name: source.name })),
  ),
);

const sourceForProject = (projectId: string) =>
  readSourceForProject(projectId).pipe(
    Effect.map((value) => value ?? undefined),
    Effect.catchTag("RailwayForbidden", () => Effect.undefined),
  );

const listProjectServices = (projectId: string) =>
  fetchProjectServices(projectId, serviceFields).pipe(
    Effect.map((services) => services.filter((node) => !isGoneService(node))),
    Effect.catchTag("RailwayNotFound", () => Effect.succeed([] as CloudService[])),
  );

const readService = Query.fn((id: string) => serviceFields(Railway.service({ id })));

const hydrateService = (serviceId: string) =>
  readService(serviceId).pipe(
    Effect.map((service) => (isGoneService(service) ? undefined : service)),
    Effect.catchTag("RailwayNotFound", () => Effect.undefined),
  );

const hydrateServices = (services: readonly CloudService[]) =>
  Effect.forEach(services, (service) => hydrateService(service.id), { concurrency: 4 }).pipe(
    Effect.map((rows) => rows.filter((row): row is CloudService => row !== undefined)),
  );

const matchingServices = (input: {
  services: readonly CloudService[];
  templateId: string;
  sourceId: string | undefined;
  ownsProject: boolean;
}): CloudService[] => {
  const byTemplate = input.services.filter((service) => service.templateId === input.templateId);
  if (byTemplate.length > 0) return byTemplate;
  if (input.sourceId === input.templateId || input.ownsProject) {
    return [...input.services];
  }
  return [];
};

const parseConfig = (config: unknown) =>
  Effect.sync(() => {
    if (typeof config !== "string") return config;
    try {
      return JSON.parse(config) as unknown;
    } catch {
      return config;
    }
  });

const normalizeVariables = (variables: unknown): unknown => {
  if (!isRecord(variables)) return variables;
  const out: Record<string, unknown> = {};
  for (const [key, item] of Object.entries(variables)) {
    if (!isRecord(item)) {
      out[key] = item;
      continue;
    }
    const value =
      typeof item.value === "string"
        ? item.value
        : typeof item.defaultValue === "string"
          ? item.defaultValue
          : "";
    out[key] = { ...item, value };
  }
  return out;
};

const normalizeConfig = (config: unknown): unknown => {
  if (!isRecord(config) || !isRecord(config.services)) return config;
  const services: Record<string, unknown> = {};
  for (const [id, service] of Object.entries(config.services)) {
    if (!isRecord(service)) {
      services[id] = service;
      continue;
    }
    services[id] =
      service.variables === undefined
        ? service
        : { ...service, variables: normalizeVariables(service.variables) };
  }
  return { ...config, services };
};

const readWorkflowStatus = Query.fn((workflowId: string) => {
  const result = Railway.workflowStatus({ workflowId });
  return { status: result.status, error: result.error };
});

const waitForWorkflow = (workflowId: string, projectId: string) =>
  Effect.gen(function* () {
    const result = yield* readWorkflowStatus(workflowId);
    if (result.status === "Complete") return result;
    if (result.status === "Error") {
      return yield* new TemplateWorkflowFailed({
        workflowId,
        error: result.error ?? "template deploy failed",
      });
    }
    return yield* new TemplatePending({ projectId, state: result.status });
  }).pipe(
    Effect.retry({
      while: (e) => e._tag === "Railway.TemplatePending",
      times: 10,
      schedule: Schedule.spaced("3 seconds"),
    }),
  );

const waitForServices = (input: {
  projectId: string;
  templateId: string;
  sourceId: string | undefined;
  ownsProject: boolean;
}) =>
  listProjectServices(input.projectId).pipe(
    Effect.flatMap((listed) => hydrateServices(listed)),
    Effect.flatMap((services) => {
      const matched = matchingServices({
        services,
        templateId: input.templateId,
        sourceId: input.sourceId,
        ownsProject: input.ownsProject,
      });
      if (matched.length === 0) {
        return Effect.fail(new TemplatePending({ projectId: input.projectId, state: "services" }));
      }
      return Effect.succeed(matched);
    }),
    Effect.retry({
      while: (e) => e._tag === "Railway.TemplatePending",
      times: 8,
      schedule: Schedule.spaced("2 seconds"),
    }),
  );

const waitUntilServiceGone = (serviceId: string, projectId: string) =>
  hydrateService(serviceId).pipe(
    Effect.flatMap((service) =>
      service === undefined
        ? Effect.void
        : Effect.fail(new TemplatePending({ projectId, state: `service ${serviceId} deletion` })),
    ),
    Effect.retry({
      schedule: Schedule.spaced("1 second"),
      while: (error) => error._tag === "Railway.TemplatePending",
      times: 8,
    }),
  );

const waitUntilProjectGone = (projectId: string) =>
  getProject(projectId).pipe(
    Effect.flatMap((project) =>
      project === undefined
        ? Effect.void
        : Effect.fail(new TemplatePending({ projectId, state: "project deletion" })),
    ),
    Effect.retry({
      schedule: Schedule.spaced("1 second"),
      while: (error) => error._tag === "Railway.TemplatePending",
      times: 8,
    }),
  );

const templateDeploy = Query.fn((input: TemplateDeployV2Input) => {
  const deployed = Railway.templateDeployV2({ input });
  return { projectId: deployed.projectId, workflowId: deployed.workflowId };
});

const serviceDelete = Query.fn((id: string) => Railway.serviceDelete({ id }));

const projectDelete = Query.fn((id: string) => Railway.projectDelete({ id }));

const observeDeployment = Effect.fn(function* (input: {
  projectId: string;
  templateId: string;
  ownsProject: boolean;
}) {
  const project = yield* getProject(input.projectId);
  if (project === undefined) {
    return undefined;
  }
  const source = yield* sourceForProject(input.projectId);
  const listed = yield* listProjectServices(input.projectId);
  const services = yield* hydrateServices(listed);
  const matched = matchingServices({
    services,
    templateId: input.templateId,
    sourceId: source?.id,
    ownsProject: input.ownsProject,
  });
  return { project, source, services: matched };
});

export const TemplateProvider = () =>
  Provider.succeed(Template, {
    stables: ["templateId", "code", "projectId", "workspaceId"],
    nuke: { dependsOn: ["Railway.Project"] },

    diff: Effect.fn(function* ({ news, output }) {
      if (news === undefined || !isResolved(news)) return undefined;
      if (output === undefined) return undefined;
      const templateChanged =
        news.templateId !== output.templateId && news.templateId !== output.code;
      const nextProject = projectIdOf(news.project);
      const projectChanged = nextProject !== undefined && nextProject !== output.projectId;
      const nextEnv = environmentIdOf(news.environment);
      const environmentChanged = nextEnv !== undefined && nextEnv !== output.environmentId;
      if (templateChanged || projectChanged || environmentChanged) {
        return { action: "replace" as const };
      }
      return undefined;
    }),

    read: Effect.fn(function* ({ olds, output }) {
      const templateRef = output?.templateId ?? olds?.templateId;
      if (templateRef === undefined || templateRef.length === 0) {
        return undefined;
      }
      const marketplace = yield* resolveMarketplaceTemplate(templateRef);
      const templateId = marketplace?.id ?? output?.templateId ?? templateRef;
      const projectId =
        output?.projectId ?? (olds !== undefined ? projectIdOf(olds.project) : undefined);
      if (projectId === undefined) return undefined;
      const ownsProject = output?.ownsProject ?? olds?.project === undefined;
      const observed = yield* observeDeployment({ projectId, templateId, ownsProject });
      if (observed === undefined || observed.services.length === 0) {
        return undefined;
      }
      const template = marketplace ?? observed.source;
      if (template === undefined) return undefined;
      const environmentId =
        output?.environmentId ??
        (olds !== undefined
          ? (environmentIdOf(olds.environment) ?? environmentIdOf(olds.project))
          : undefined) ??
        environmentIdFromProject(observed.project);
      const workspaceId =
        output?.workspaceId ??
        (olds !== undefined ? workspaceIdOf(olds.project) : undefined) ??
        projectWorkspaceId(observed.project);
      const attrs = toAttrs({
        template,
        project: observed.project,
        environmentId,
        workspaceId,
        serviceIds: observed.services.map((service) => service.id),
        workflowId: output?.workflowId,
        ownsProject,
      });
      if (output !== undefined) return attrs;
      return matchesAlchemyPhysicalName(observed.project.name) ? attrs : Unowned(attrs);
    }),

    list: Effect.fn(function* () {
      const projects = yield* ownedProjects();
      const rows = yield* Effect.forEach(projects, (project) =>
        Effect.gen(function* () {
          const live = yield* readProject(project.projectId).pipe(
            Effect.catchTag("RailwayNotFound", () => Effect.undefined),
          );
          if (live === undefined || live.deletedAt != null) {
            return [] as Template["Attributes"][];
          }
          const services = yield* listProjectServices(project.projectId);
          const source = yield* sourceForProject(project.projectId);
          const deployments = new Map<string, CloudService[]>();
          for (const service of services) {
            const templateId = service.templateId ?? source?.id;
            if (templateId == null) continue;
            const group = deployments.get(templateId) ?? [];
            group.push(service);
            deployments.set(templateId, group);
          }
          return yield* Effect.forEach(deployments, ([templateId, members]) =>
            Effect.gen(function* () {
              const template =
                source?.id === templateId
                  ? source
                  : yield* readTemplateSummary(templateId).pipe(
                      Effect.catchTag("RailwayForbidden", () => Effect.succeed({ id: templateId })),
                    );
              return toAttrs({
                template: template ?? { id: templateId },
                project: live,
                environmentId: project.environmentId,
                workspaceId: project.workspaceId,
                serviceIds: members.map((service) => service.id),
                workflowId: undefined,
                ownsProject: false,
              });
            }),
          );
        }),
      );
      const seen = new Set<string>();
      const unique: Template["Attributes"][] = [];
      for (const row of rows.flat()) {
        const key = `${row.projectId}:${row.templateId}`;
        if (seen.has(key)) continue;
        seen.add(key);
        unique.push(row);
      }
      return unique;
    }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const props = news ?? ({} as TemplateProps);
      const templateRef = props.templateId ?? output?.templateId;
      if (templateRef === undefined || templateRef.length === 0) {
        return yield* new TemplateNotFound({ templateId: "" });
      }
      const marketplace = yield* resolveMarketplaceTemplate(templateRef);
      if (marketplace === undefined) {
        return yield* new TemplateNotFound({ templateId: templateRef });
      }

      const providedProject = props.project !== undefined;
      let ownsProject = providedProject ? false : (output?.ownsProject ?? true);
      let projectId = projectIdOf(props.project) ?? output?.projectId;
      let environmentId =
        environmentIdOf(props.environment) ??
        environmentIdOf(props.project) ??
        output?.environmentId;
      let workspaceId =
        workspaceIdOf(props.project) ?? output?.workspaceId ?? (yield* currentWorkspaceId());

      let current: CloudProject | undefined =
        projectId !== undefined && projectId.length > 0 ? yield* getProject(projectId) : undefined;

      if (current === undefined && !providedProject) {
        const name = yield* createRailwayName(id);
        const created = yield* createProject({ name, workspaceId }).pipe(
          Effect.catchTag("RailwayValidationError", () => Effect.undefined),
        );
        current = created;
        ownsProject = true;
      }

      if (current === undefined || isGoneProject(current)) {
        return yield* new TemplateNotCreated({
          templateId: marketplace.id,
          projectId: projectId ?? "",
        });
      }

      projectId = current.id;
      environmentId =
        environmentId && environmentId.length > 0
          ? environmentId
          : environmentIdFromProject(current);
      workspaceId = projectWorkspaceId(current, workspaceId);

      const observed = yield* observeDeployment({
        projectId,
        templateId: marketplace.id,
        ownsProject,
      });
      let services = observed?.services ?? [];
      let workflowId = output?.workflowId;

      if (services.length === 0) {
        const rawConfig = props.serializedConfig ?? marketplace.serializedConfig;
        if (rawConfig == null) {
          return yield* new TemplateConfigRequired({ templateId: marketplace.id });
        }
        const parsed = yield* parseConfig(rawConfig);
        const serializedConfig = normalizeConfig(parsed);
        const deployed = yield* templateDeploy({
          templateId: marketplace.id,
          serializedConfig,
          projectId,
          ...(environmentId.length > 0 ? { environmentId } : {}),
          workspaceId,
        });
        projectId = deployed.projectId || projectId;
        workflowId = deployed.workflowId ?? workflowId;
        if (deployed.projectId.length > 0 && deployed.projectId !== current.id) {
          const created = yield* getProject(deployed.projectId);
          if (created !== undefined) current = created;
        }
        if (workflowId !== undefined && workflowId.length > 0) {
          yield* waitForWorkflow(workflowId, projectId);
        }
        const source = yield* sourceForProject(projectId);
        services = yield* waitForServices({
          projectId,
          templateId: marketplace.id,
          sourceId: source?.id,
          ownsProject,
        });
      }

      if (services.length === 0) {
        return yield* new TemplateNotCreated({ templateId: marketplace.id, projectId });
      }

      const live = (yield* getProject(projectId)) ?? current;
      if (environmentId.length === 0) {
        environmentId = environmentIdFromProject(live);
      }

      return toAttrs({
        template: marketplace,
        project: live,
        environmentId,
        workspaceId,
        serviceIds: services.map((service) => service.id),
        workflowId,
        ownsProject,
      });
    }),

    delete: Effect.fn(function* ({ output }) {
      const serviceIds = output.serviceIds ?? [];
      for (const serviceId of serviceIds) {
        if (serviceId.length === 0) continue;
        yield* serviceDelete(serviceId).pipe(Effect.catchTag("RailwayNotFound", () => Effect.void));
        yield* waitUntilServiceGone(serviceId, output.projectId);
      }
      if (!output.ownsProject) return;
      const projectId = output.projectId;
      if (projectId.length === 0) return;
      yield* projectDelete(projectId).pipe(Effect.catchTag("RailwayNotFound", () => Effect.void));
      yield* waitUntilProjectGone(projectId);
    }),
  });