import { GraphQLLive } from "@distilled.cloud/railway";
import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
import { ProfileStoreLive } from "alchemy/Auth/Profile";
import * as Command from "alchemy/Command";
import * as Provider from "alchemy/Provider";
import { Random, RandomProvider } from "alchemy/Random";
import {
Server as WebsiteServer,
ServerProvider as WebsiteServerProvider,
} from "alchemy/Website/Server";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as Layer from "effect/Layer";
import { RailwayAuth } from "./AuthProvider.ts";
import { Bucket, BucketProvider } from "./Bucket.ts";
import { CloudAgent, CloudAgentProvider } from "./CloudAgent.ts";
import { ConnectMongoHttp } from "./ConnectMongoHttp.ts";
import { ConnectMySQLHttp } from "./ConnectMySQLHttp.ts";
import { ConnectPostgresHttp } from "./ConnectPostgresHttp.ts";
import * as Credentials from "./Credentials.ts";
import { CustomDomain, CustomDomainProvider } from "./CustomDomain.ts";
import { DeleteObjectHttp } from "./DeleteObjectHttp.ts";
import { fromCredentials } from "./Environment.ts";
import { Function, FunctionProvider } from "./Function.ts";
import { GetObjectHttp } from "./GetObjectHttp.ts";
import { Group, GroupProvider } from "./Group.ts";
import { HeadObjectHttp } from "./HeadObjectHttp.ts";
import { ListObjectsV2Http } from "./ListObjectsV2Http.ts";
import { Mongo, MongoProvider } from "./Mongo.ts";
import { MountVolumeLive } from "./MountVolume.ts";
import { MySQL, MySQLProvider } from "./MySQL.ts";
import { Postgres, PostgresProvider } from "./Postgres.ts";
import {
PrivateNetwork,
PrivateNetworkEndpoint,
PrivateNetworkEndpointProvider,
PrivateNetworkProvider,
} from "./PrivateNetwork.ts";
import { Project, ProjectProvider } from "./Project.ts";
import { Environment, EnvironmentProvider } from "./ProjectEnvironment.ts";
import { PutObjectHttp } from "./PutObjectHttp.ts";
import { ReadRedisHttp } from "./ReadRedisHttp.ts";
import { ReadWriteRedisHttp } from "./ReadWriteRedisHttp.ts";
import { Redis, RedisProvider } from "./Redis.ts";
import { ExecHttp, Sandbox, SandboxProvider } from "./Sandbox.ts";
import { SandboxCheckpoint, SandboxCheckpointProvider } from "./SandboxCheckpoint.ts";
import { Service } from "./Service.ts";
import { ServiceProvider } from "./ServiceProvider.ts";
import { TcpProxy, TcpProxyProvider } from "./TcpProxy.ts";
import { Template, TemplateProvider } from "./Template.ts";
import { UsageLimit, UsageLimitProvider } from "./Usage.ts";
import { Variable, VariableProvider } from "./Variable.ts";
import { Volume, VolumeProvider } from "./Volume.ts";
import { VolumeBackup, VolumeBackupProvider } from "./VolumeBackup.ts";
import { Cdn, CdnProvider } from "./Website/Cdn.ts";
import { WriteRedisHttp } from "./WriteRedisHttp.ts";
export class Providers extends Provider.ProviderCollection<Providers>()("Railway") {}
export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
/**
* Build a layer that registers Railway resource providers, the Railway
* `AuthProvider`, the resolved `Credentials`, and an `HttpClient`. Include
* this from your stack alongside other cloud `providers()` layers.
*
* Resource providers are inserted into {@link Provider.collection} as they
* land. The collection starts empty so Project / Service agents can make a
* single minimal insertion.
*
* @example
* ```typescript
* import * as Alchemy from "alchemy";
* import * as Railway from "@alchemy.run/railway";
* import * as Effect from "effect/Effect";
*
* export default Alchemy.Stack(
* "MyStack",
* {
* providers: Railway.providers(),
* state: Alchemy.localState(),
* },
* Effect.gen(function* () {
* return {};
* }),
* );
* ```
*/
export const providers = () =>
Layer.effect(
Providers,
Provider.collection([
Project,
Postgres,
PrivateNetwork,
PrivateNetworkEndpoint,
MySQL,
Mongo,
Cdn,
CustomDomain,
Environment,
Function,
Group,
Service,
TcpProxy,
Template,
UsageLimit,
Variable,
Volume,
VolumeBackup,
Redis,
Bucket,
CloudAgent,
Sandbox,
SandboxCheckpoint,
Random,
WebsiteServer,
]),
).pipe(
Layer.provide(
Layer.mergeAll(
ProjectProvider(),
PostgresProvider(),
PrivateNetworkProvider(),
PrivateNetworkEndpointProvider(),
MySQLProvider(),
MongoProvider(),
CdnProvider(),
CustomDomainProvider(),
EnvironmentProvider(),
FunctionProvider(),
GroupProvider(),
ServiceProvider(),
TcpProxyProvider(),
TemplateProvider(),
UsageLimitProvider(),
VariableProvider(),
VolumeProvider(),
VolumeBackupProvider(),
RedisProvider(),
BucketProvider(),
CloudAgentProvider(),
SandboxProvider(),
SandboxCheckpointProvider(),
RandomProvider(),
WebsiteServerProvider(),
),
),
Layer.provideMerge(
Layer.mergeAll(
MountVolumeLive,
ConnectPostgresHttp,
ConnectMySQLHttp,
ConnectMongoHttp,
PutObjectHttp,
GetObjectHttp,
DeleteObjectHttp,
HeadObjectHttp,
ListObjectsV2Http,
ReadRedisHttp,
WriteRedisHttp,
ReadWriteRedisHttp,
ExecHttp,
),
),
Layer.provideMerge(fromCredentials()),
Layer.provideMerge(GraphQLLive),
Layer.provideMerge(Credentials.fromAuthProvider()),
Layer.provideMerge(RailwayAuth),
Layer.provideMerge(ProfileStoreLive),
Layer.provideMerge(CredentialsStoreLive),
Layer.provideMerge(FetchHttpClient.layer),
Layer.provideMerge(Command.providers()),
Layer.orDie,
);