ff-serv 0.1.4 → 0.1.6

package/package.json

@@ -1,7 +1,10 @@
 {
 	"name": "ff-serv",
-	"version": "0.1.4",
+	"version": "0.1.6",
 	"type": "module",
+	"bin": {
+		"ff-serv": "./dist/cli"
+	},
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
@@ -19,15 +22,22 @@
 		"src"
 	],
 	"scripts": {
-		"build": "tsup",
+		"build": "tsup && bun run build:cli",
+		"build:cli": "bun build src/cli/index.ts --production --target=bun --outfile dist/cli.js",
 		"test": "bun -b vitest run",
 		"dev": "tsup --watch"
 	},
 	"devDependencies": {
+		"@effect/cli": "^0.71.0",
+		"@effect/platform-bun": "^0.87.0",
 		"@effect/vitest": "^0.27.0",
 		"@orpc/client": "^1.13.2",
 		"@types/bun": "^1.3.2",
+		"@types/cli-progress": "^3.11.6",
+		"cli-progress": "^3.12.0",
 		"ff-effect": "^0.0.7",
+		"inquirer": "^12.10.0",
+		"postgres": "^3.4.7",
 		"tsup": "^8.5.0",
 		"typescript": "^5.9.3",
 		"vitest": "^4.0.16"
@@ -59,4 +69,4 @@
 		"@effect/platform": "^0.94.1",
 		"nanoid": "^5.1.6"
 	}
-}
+}

package/src/cli/commands/db/dump.ts

@@ -0,0 +1,37 @@
+import * as cli from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { loadConfig } from '../../config/index.js';
+import {
+	dumpToFile,
+	getDatabaseUrlFromSource,
+	resolveDatabaseSource,
+} from './shared.js';
+
+export const dumpCommand = cli.Command.make(
+	'dump',
+	{
+		output: cli.Options.file('output').pipe(
+			cli.Options.withAlias('o'),
+			cli.Options.withDefault('./dump.sql'),
+		),
+		config: cli.Options.file('config').pipe(cli.Options.optional),
+	},
+	({ output, config }) =>
+		Effect.gen(function* () {
+			const loadedConfig = yield* loadConfig(
+				Option.isSome(config) ? config.value : undefined,
+			);
+
+			const source = yield* resolveDatabaseSource(
+				Option.isSome(loadedConfig) && loadedConfig.value.pullDatabase?.source
+					? loadedConfig.value.pullDatabase.source
+					: undefined,
+			);
+
+			const sourceUrl = yield* getDatabaseUrlFromSource(source);
+
+			yield* Effect.log(`Dumping database to: ${output}`);
+			yield* dumpToFile(sourceUrl, output);
+			yield* Effect.log(`Database dump complete: ${output}`);
+		}).pipe(Effect.scoped),
+);

package/src/cli/commands/db/index.ts

@@ -0,0 +1,8 @@
+import * as cli from '@effect/cli';
+import { Effect } from 'effect';
+import { dumpCommand } from './dump.js';
+import { pullCommand } from './pull.js';
+
+export const dbCommand = cli.Command.make('db', {}, () =>
+	Effect.log('Database commands - UsepullCommandle subcommands'),
+).pipe(cli.Command.withSubcommands([pullCommand, dumpCommand]));

package/src/cli/commands/db/pull.ts

@@ -0,0 +1,338 @@
+import * as cli from '@effect/cli';
+import * as platform from '@effect/platform';
+import { Effect, Option, Cause } from 'effect';
+import inquirer from 'inquirer';
+import postgres from 'postgres';
+import { loadConfig } from '../../config/index.js';
+import {
+	promptCleanupDump,
+	promptRetry,
+	promptTargetUrl,
+} from '../../utils/prompts.js';
+import {
+	dumpToFile,
+	getDatabaseUrlFromSource,
+	resolveDatabaseSource,
+} from './shared.js';
+
+const DEFAULT_TARGET_DATABASE_URL =
+	'postgresql://postgres:supersecret@postgres:5432/postgres';
+
+type DatabaseInfo = {
+	host: string;
+	port: string;
+	database: string;
+	user: string;
+};
+
+const parsePostgresUrl = (url: string): DatabaseInfo => {
+	const parsed = new URL(url);
+	return {
+		host: parsed.hostname || 'localhost',
+		port: parsed.port || '5432',
+		database: parsed.pathname.slice(1) || 'postgres',
+		user: parsed.username || 'postgres',
+	};
+};
+
+const confirmDatabaseUrls = (
+	sourceUrl: string | null,
+	targetUrl: string,
+) =>
+	Effect.gen(function* () {
+		const target = parsePostgresUrl(targetUrl);
+
+		if (sourceUrl) {
+			const source = parsePostgresUrl(sourceUrl);
+			yield* Effect.log('\n--- Source Database ---');
+			yield* Effect.log(`Host: ${source.host}`);
+			yield* Effect.log(`Port: ${source.port}`);
+			yield* Effect.log(`Database: ${source.database}`);
+		} else {
+			yield* Effect.log('\n--- Source ---');
+			yield* Effect.log('Local dump file');
+		}
+
+		yield* Effect.log('\n--- Target Database ---');
+		yield* Effect.log(`Host: ${target.host}`);
+		yield* Effect.log(`Port: ${target.port}`);
+		yield* Effect.log(`Database: ${target.database}`);
+
+		return yield* Effect.tryPromise(() =>
+			inquirer.prompt([
+				{
+					type: 'confirm',
+					name: 'confirmed',
+					message: 'Are the settings correct?',
+					default: false,
+				},
+			]),
+		).pipe(Effect.map((r) => r.confirmed as boolean));
+	});
+
+type SchemaTableInfo = {
+	schema: string;
+	tables: string[];
+};
+
+const getSchemaTablesInfo = (databaseUrl: string) =>
+	Effect.gen(function* () {
+		const conn = postgres(databaseUrl);
+		yield* Effect.addFinalizer(() =>
+			Effect.ignore(Effect.tryPromise(() => conn.end())),
+		);
+
+		const schemas = yield* Effect.tryPromise(
+			() =>
+				conn<[{ schema_name: string }]>`
+			SELECT schema_name
+			FROM information_schema.schemata
+			WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+			ORDER BY schema_name
+		`,
+		);
+
+		const schemaTableInfo: SchemaTableInfo[] = [];
+
+		for (const { schema_name } of schemas) {
+			const tables = yield* Effect.tryPromise(
+				() =>
+					conn<[{ table_name: string }]>`
+				SELECT table_name
+				FROM information_schema.tables
+				WHERE table_schema = ${schema_name}
+				ORDER BY table_name
+			`,
+			);
+
+			schemaTableInfo.push({
+				schema: schema_name,
+				tables: tables.map((t) => t.table_name),
+			});
+		}
+
+		return schemaTableInfo;
+	});
+
+const confirmDatabaseReset = (databaseUrl: string) =>
+	Effect.gen(function* () {
+		const schemaInfo = yield* getSchemaTablesInfo(databaseUrl);
+
+		yield* Effect.log('\nThe following will be truncated:\n');
+
+		for (const { schema, tables } of schemaInfo) {
+			if (tables.length === 0) {
+				yield* Effect.log(`Schema: ${schema}`);
+				yield* Effect.log('  (no tables)\n');
+				continue;
+			}
+
+			yield* Effect.log(`Schema: ${schema}`);
+			for (const table of tables) {
+				yield* Effect.log(`  - ${table}`);
+			}
+			yield* Effect.log('');
+		}
+
+		const { shouldReset } = yield* Effect.tryPromise(() =>
+			inquirer.prompt([
+				{
+					type: 'confirm',
+					name: 'shouldReset',
+					message: 'Proceed with truncation?',
+					default: false,
+				},
+			]),
+		);
+
+		return { shouldReset: shouldReset as boolean, schemaInfo };
+	});
+
+const truncateAllTables = (
+	databaseUrl: string,
+	schemaInfo: SchemaTableInfo[],
+) =>
+	Effect.gen(function* () {
+		const conn = postgres(databaseUrl);
+		yield* Effect.addFinalizer(() =>
+			Effect.ignore(Effect.tryPromise(() => conn.end())),
+		);
+
+		yield* Effect.log(`Truncating ${schemaInfo.length} schema(s)...`);
+
+		for (const { schema, tables } of schemaInfo) {
+			if (tables.length === 0) {
+				yield* Effect.log(`  No tables in "${schema}"`);
+				continue;
+			}
+
+			yield* Effect.log(
+				`Truncating ${tables.length} table(s) in schema "${schema}"...`,
+			);
+
+			const tableNames = tables
+				.map((t) => `"${schema}"."${t}"`)
+				.join(', ');
+
+			yield* Effect.tryPromise(() =>
+				conn.unsafe(`TRUNCATE ${tableNames} RESTART IDENTITY CASCADE`),
+			);
+		}
+
+		yield* Effect.log('Database reset complete');
+	});
+
+const restoreFromFile = (databaseUrl: string, filePath: string) =>
+	Effect.gen(function* () {
+		yield* Effect.log('Restoring from file');
+		yield* platform.Command.make('psql', databaseUrl, '-f', filePath).pipe(
+			platform.Command.stdout('inherit'),
+			platform.Command.exitCode,
+		);
+	});
+
+const createDumpFile = Effect.gen(function* () {
+	const fs = yield* platform.FileSystem.FileSystem;
+	const path = yield* platform.Path.Path;
+	const tmpDir = yield* fs.makeTempDirectory();
+	const file = path.join(tmpDir, 'dump.sql');
+	yield* Effect.log(`Prepared dump file: ${file}`);
+	return file;
+});
+
+const saveDumpToPath = (sourcePath: string, destinationPath: string) =>
+	Effect.gen(function* () {
+		const fs = yield* platform.FileSystem.FileSystem;
+		yield* fs.copy(sourcePath, destinationPath);
+		yield* Effect.log(`Dump saved to: ${destinationPath}`);
+	});
+
+interface DumpState {
+	filePath: string;
+	downloaded: boolean;
+}
+
+const executeWithRetry = <A, E, R>(
+	operation: Effect.Effect<A, E, R>,
+	dumpState: DumpState,
+): Effect.Effect<A, E | Cause.UnknownException, R> =>
+	Effect.catchAll(operation, (error) =>
+		Effect.gen(function* () {
+			yield* Effect.logError(`Operation failed: ${error}`);
+
+			if (dumpState.downloaded) {
+				yield* Effect.log(`Dump file preserved at: ${dumpState.filePath}`);
+				yield* Effect.log('You can retry using --fromDump flag');
+			}
+
+			const shouldRetry = yield* promptRetry;
+
+			if (shouldRetry) {
+				yield* Effect.log('Retrying...');
+				return yield* executeWithRetry(operation, dumpState);
+			}
+
+			return yield* Effect.fail(error);
+		}),
+	);
+
+export const pullCommand = cli.Command.make(
+	'pull',
+	{
+		fromDump: cli.Options.file('fromDump').pipe(cli.Options.optional),
+		targetDatabaseUrl: cli.Args.text({ name: 'targetDatabaseUrl' }).pipe(
+			cli.Args.optional,
+		),
+		saveDump: cli.Options.file('saveDump').pipe(cli.Options.optional),
+		config: cli.Options.file('config').pipe(cli.Options.optional),
+	},
+	({ fromDump, targetDatabaseUrl, saveDump, config }) =>
+		Effect.gen(function* () {
+			const loadedConfig = yield* loadConfig(
+				Option.isSome(config) ? config.value : undefined,
+			);
+
+			const targetUrl =
+				Option.getOrUndefined(targetDatabaseUrl) ||
+				Option.flatMap(loadedConfig, (c) =>
+					Option.fromNullable(c.pullDatabase?.targetDatabaseUrl),
+				).pipe(Option.getOrUndefined) ||
+				(yield* promptTargetUrl(DEFAULT_TARGET_DATABASE_URL));
+
+			let dumpState: DumpState;
+
+			if (Option.isSome(fromDump)) {
+				dumpState = { filePath: fromDump.value, downloaded: true };
+				yield* Effect.log(`Using dump file: ${dumpState.filePath}`);
+
+				const confirmed = yield* confirmDatabaseUrls(null, targetUrl);
+				if (!confirmed) {
+					yield* Effect.log('Operation cancelled');
+					return;
+				}
+			} else {
+				const dumpPath = yield* createDumpFile;
+				dumpState = { filePath: dumpPath, downloaded: false };
+
+				const source = yield* resolveDatabaseSource(
+					Option.flatMap(loadedConfig, (c) =>
+						Option.fromNullable(c.pullDatabase?.source),
+					).pipe(Option.getOrUndefined),
+				);
+
+				const sourceUrl = yield* getDatabaseUrlFromSource(source);
+
+				const urlsConfirmed = yield* confirmDatabaseUrls(
+					sourceUrl,
+					targetUrl,
+				);
+				if (!urlsConfirmed) {
+					yield* Effect.log('Operation cancelled');
+					return;
+				}
+
+				yield* executeWithRetry(
+					dumpToFile(sourceUrl, dumpState.filePath).pipe(
+						Effect.tap(() =>
+							Effect.sync(() => {
+								dumpState.downloaded = true;
+							}),
+						),
+					),
+					dumpState,
+				);
+
+				if (Option.isSome(saveDump)) {
+					yield* saveDumpToPath(dumpState.filePath, saveDump.value);
+				}
+			}
+
+			yield* executeWithRetry(
+				Effect.gen(function* () {
+					const { shouldReset, schemaInfo } =
+						yield* confirmDatabaseReset(targetUrl);
+					if (shouldReset) {
+						yield* truncateAllTables(targetUrl, schemaInfo);
+					}
+
+					yield* restoreFromFile(targetUrl, dumpState.filePath);
+				}),
+				dumpState,
+			);
+
+			if (!Option.isSome(fromDump)) {
+				const shouldCleanup = yield* promptCleanupDump(
+					dumpState.filePath,
+				);
+				if (shouldCleanup) {
+					const fs = yield* platform.FileSystem.FileSystem;
+					yield* fs.remove(dumpState.filePath, { recursive: true });
+					yield* Effect.log('Dump file cleaned up');
+				} else {
+					yield* Effect.log(`Dump file kept at: ${dumpState.filePath}`);
+				}
+			}
+
+			yield* Effect.log('Database pull complete!');
+		}).pipe(Effect.scoped),
+);

package/src/cli/commands/db/shared.ts

@@ -0,0 +1,112 @@
+import * as platform from '@effect/platform';
+import cliProgress from 'cli-progress';
+import { Effect, Fiber } from 'effect';
+import type { DatabaseSourceConfig } from '../../config/schema.js';
+import {
+	createDirectSource,
+	createRailwaySource,
+	type DatabaseSource,
+} from '../../utils/database-source.js';
+import {
+	promptDatabaseSourceType,
+	promptDirectUrl,
+	promptRailwayConfig,
+} from '../../utils/prompts.js';
+
+export const getDatabaseUrlFromSource = (source: DatabaseSource) =>
+	Effect.gen(function* () {
+		yield* Effect.log(`Getting database URL from ${source.displayName}...`);
+		return yield* source.getConnectionUrl;
+	});
+
+export const dumpToFile = (databaseUrl: string, filePath: string) =>
+	Effect.gen(function* () {
+		const fs = yield* platform.FileSystem.FileSystem;
+
+		const bar = new cliProgress.SingleBar({
+			format: 'Dumping |{bar}| {fileSize} MB ({rate} MB/s)',
+			barCompleteChar: '\u2588',
+			barIncompleteChar: '\u2591',
+			hideCursor: true,
+		});
+
+		const process = yield* platform.Command.make(
+			'pg_dump',
+			databaseUrl,
+			'--file',
+			filePath,
+		).pipe(platform.Command.start);
+
+		bar.start(100, 0, { fileSize: '0', rate: '0' });
+
+		const startTime = Date.now();
+		let lastSize = 0n;
+		let lastCheckTime = startTime;
+
+		const fileSizeMonitor = Effect.gen(function* () {
+			while (true) {
+				yield* Effect.sleep('500 millis');
+
+				const stat = yield* fs
+					.stat(filePath)
+					.pipe(Effect.catchAll(() => Effect.succeed({ size: 0n })));
+				const now = Date.now();
+				const elapsed = (now - startTime) / 1000;
+				const sizeBytes = Number(stat.size);
+				const sizeMB = (sizeBytes / 1024 / 1024).toFixed(2);
+
+				const timeSinceLastCheck = (now - lastCheckTime) / 1000;
+				const bytesSinceLastCheck = Number(stat.size - lastSize);
+				const rateMB =
+					timeSinceLastCheck > 0
+						? (
+								bytesSinceLastCheck /
+								1024 /
+								1024 /
+								timeSinceLastCheck
+							).toFixed(2)
+						: '0';
+
+				bar.update(elapsed, {
+					fileSize: sizeMB,
+					rate: rateMB,
+				});
+
+				lastSize = stat.size;
+				lastCheckTime = now;
+			}
+		});
+
+		const monitorFiber = yield* Effect.fork(fileSizeMonitor);
+		yield* process.exitCode;
+		yield* Fiber.interrupt(monitorFiber);
+
+		bar.stop();
+		yield* Effect.log('Dump complete');
+	});
+
+export const resolveDatabaseSource = (
+	sourceConfig?: DatabaseSourceConfig,
+): Effect.Effect<DatabaseSource, Effect.Effect.Error<typeof promptDatabaseSourceType>> =>
+	Effect.gen(function* () {
+		if (sourceConfig) {
+			if (sourceConfig.type === 'railway') {
+				return createRailwaySource({
+					projectId: sourceConfig.projectId,
+					environmentId: sourceConfig.environmentId,
+					serviceId: sourceConfig.serviceId,
+				});
+			}
+			return createDirectSource(sourceConfig.databaseUrl);
+		}
+
+		const sourceType = yield* promptDatabaseSourceType;
+
+		if (sourceType === 'railway') {
+			const config = yield* promptRailwayConfig;
+			return createRailwaySource(config);
+		}
+
+		const url = yield* promptDirectUrl;
+		return createDirectSource(url);
+	});

package/src/cli/config/index.ts

@@ -0,0 +1,80 @@
+import * as platform from '@effect/platform';
+import { Effect, Option, Schema } from 'effect';
+import { FfServConfig } from './schema.js';
+
+const DEFAULT_CONFIG_PATHS = ['.ff-serv.json', 'ff-serv.config.json'];
+
+const tryLoadConfigFromPath = (
+	filePath: string,
+): Effect.Effect<
+	Option.Option<FfServConfig>,
+	never,
+	platform.FileSystem.FileSystem
+> =>
+	Effect.gen(function* () {
+		const fs = yield* platform.FileSystem.FileSystem;
+
+		const exists = yield* fs
+			.exists(filePath)
+			.pipe(Effect.catchAll(() => Effect.succeed(false)));
+
+		if (!exists) {
+			return Option.none<FfServConfig>();
+		}
+
+		const contentResult = yield* fs
+			.readFileString(filePath)
+			.pipe(Effect.either);
+
+		if (contentResult._tag === 'Left') {
+			return Option.none<FfServConfig>();
+		}
+
+		const parseResult = yield* Effect.try(() =>
+			JSON.parse(contentResult.right),
+		).pipe(Effect.either);
+
+		if (parseResult._tag === 'Left') {
+			yield* Effect.logWarning(`Failed to parse config file: ${filePath}`);
+			return Option.none<FfServConfig>();
+		}
+
+		const validateResult = yield* Schema.decodeUnknown(FfServConfig)(
+			parseResult.right,
+		).pipe(Effect.either);
+
+		if (validateResult._tag === 'Left') {
+			yield* Effect.logWarning(`Invalid config schema in: ${filePath}`);
+			return Option.none<FfServConfig>();
+		}
+
+		return Option.some(validateResult.right);
+	});
+
+export const loadConfig = (
+	customConfigPath?: string,
+): Effect.Effect<
+	Option.Option<FfServConfig>,
+	never,
+	platform.FileSystem.FileSystem
+> =>
+	Effect.gen(function* () {
+		const pathsToTry = customConfigPath
+			? [customConfigPath]
+			: [
+					...(process.env.FF_SERV_CONFIG
+						? [process.env.FF_SERV_CONFIG]
+						: []),
+					...DEFAULT_CONFIG_PATHS,
+				];
+
+		for (const configPath of pathsToTry) {
+			const result = yield* tryLoadConfigFromPath(configPath);
+			if (Option.isSome(result)) {
+				yield* Effect.log(`Loaded config from: ${configPath}`);
+				return Option.some(result.value);
+			}
+		}
+
+		return Option.none();
+	});

package/src/cli/config/schema.ts

@@ -0,0 +1,34 @@
+import { Schema } from 'effect';
+
+const RailwaySourceConfig = Schema.Struct({
+	type: Schema.Literal('railway'),
+	projectId: Schema.String,
+	environmentId: Schema.String,
+	serviceId: Schema.String,
+});
+
+const DirectSourceConfig = Schema.Struct({
+	type: Schema.Literal('direct'),
+	databaseUrl: Schema.String,
+});
+
+export const DatabaseSourceConfig = Schema.Union(
+	RailwaySourceConfig,
+	DirectSourceConfig,
+);
+
+export const PullDatabaseConfig = Schema.Struct({
+	source: DatabaseSourceConfig,
+	targetDatabaseUrl: Schema.optional(Schema.String),
+	defaultDumpPath: Schema.optional(Schema.String),
+});
+
+export const FfServConfig = Schema.Struct({
+	pullDatabase: Schema.optional(PullDatabaseConfig),
+});
+
+export type FfServConfig = Schema.Schema.Type<typeof FfServConfig>;
+export type PullDatabaseConfig = Schema.Schema.Type<typeof PullDatabaseConfig>;
+export type DatabaseSourceConfig = Schema.Schema.Type<
+	typeof DatabaseSourceConfig
+>;

package/src/cli/index.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import * as cli from '@effect/cli';
+import * as BunContext from '@effect/platform-bun/BunContext';
+import * as BunRuntime from '@effect/platform-bun/BunRuntime';
+import { Effect } from 'effect';
+import { dbCommand } from './commands/db/index.js';
+import pkg from '../../package.json' with { type: 'json' };
+
+const rootCommand = cli.Command.make('ff-serv', {}, () =>
+	Effect.log('ff-serv CLI - Use --help for available commands'),
+).pipe(cli.Command.withSubcommands([dbCommand]));
+
+const main = cli.Command.run(rootCommand, {
+	name: 'ff-serv',
+	version: pkg.version,
+});
+
+main(process.argv).pipe(Effect.provide(BunContext.layer), BunRuntime.runMain);