ff-serv 0.1.10 → 0.1.11

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

@@ -59,12 +59,9 @@ export const dumpToFile = (databaseUrl: string, filePath: string) =>
 				const bytesSinceLastCheck = Number(stat.size - lastSize);
 				const rateMB =
 					timeSinceLastCheck > 0
-						? (
-								bytesSinceLastCheck /
-								1024 /
-								1024 /
-								timeSinceLastCheck
-							).toFixed(2)
+						? (bytesSinceLastCheck / 1024 / 1024 / timeSinceLastCheck).toFixed(
+								2,
+							)
 						: '0';
 
 				bar.update(elapsed, {
@@ -87,7 +84,10 @@ export const dumpToFile = (databaseUrl: string, filePath: string) =>
 
 export const resolveDatabaseSource = (
 	sourceConfig?: DatabaseSourceConfig,
-): Effect.Effect<DatabaseSource, Effect.Effect.Error<typeof promptDatabaseSourceType>> =>
+): Effect.Effect<
+	DatabaseSource,
+	Effect.Effect.Error<typeof promptDatabaseSourceType>
+> =>
 	Effect.gen(function* () {
 		if (sourceConfig) {
 			if (sourceConfig.type === 'railway') {

package/src/cli/config/index.ts

@@ -62,9 +62,7 @@ export const loadConfig = (
 		const pathsToTry = customConfigPath
 			? [customConfigPath]
 			: [
-					...(process.env.FF_SERV_CONFIG
-						? [process.env.FF_SERV_CONFIG]
-						: []),
+					...(process.env.FF_SERV_CONFIG ? [process.env.FF_SERV_CONFIG] : []),
 					...DEFAULT_CONFIG_PATHS,
 				];
 

package/src/cli/index.ts

@@ -3,8 +3,8 @@ 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' };
+import { dbCommand } from './commands/db/index.js';
 
 const rootCommand = cli.Command.make('ff-serv', {}, () =>
 	Effect.log('ff-serv CLI - Use --help for available commands'),

package/src/cli/utils/database-source.ts

@@ -23,10 +23,7 @@ export const createRailwaySource = (config: {
 			`--project=${config.projectId}`,
 			`--environment=${config.environmentId}`,
 			`--service=${config.serviceId}`,
-		).pipe(
-			platform.Command.stdout('inherit'),
-			platform.Command.exitCode,
-		);
+		).pipe(platform.Command.stdout('inherit'), platform.Command.exitCode);
 
 		const output = yield* platform.Command.make(
 			'railway',

package/src/exports/cache-bun-redis.ts

@@ -0,0 +1 @@
+export { bunRedis } from '../cache/adapters/bun-redis.js';

package/src/exports/cache-ioredis.ts

@@ -0,0 +1 @@
+export { ioredis } from '../cache/adapters/ioredis.js';

package/src/exports/cache.ts

@@ -0,0 +1,6 @@
+export {
+	CacheAdapter,
+	type CacheEntry,
+	type RedisClient,
+} from '../cache/adapter.js';
+export { Cache, type CacheInstance } from '../cache/cache.js';

package/src/exports/orpc.ts

@@ -1 +1 @@
-export { oRPCHandler } from '../http/orpc.js';
+export { oRPCHandler } from '../http/orpc.js';

package/src/http/fetch-handler.test.ts

@@ -75,4 +75,4 @@ layer(
 				}),
 		}),
 	);
-});
+});

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './http/index.js';
+export type { SyncLogger } from './logger.js';
 export { Logger } from './logger.js';
 export { getPort } from './port.js';

package/src/logger.test.ts

@@ -0,0 +1,168 @@
+import { it } from '@effect/vitest';
+import {
+	Effect,
+	Array as EffectArray,
+	Logger as EffectLogger,
+	Layer,
+	LogLevel,
+} from 'effect';
+import { describe, expect } from 'vitest';
+import { Logger } from './logger.js';
+
+type CapturedEntry = {
+	message: string;
+	logLevel: LogLevel.LogLevel;
+	annotations: Record<string, unknown>;
+};
+
+function makeTestLogger() {
+	const entries: Array<CapturedEntry> = [];
+
+	const logger = EffectLogger.make((options) => {
+		const annotations: Record<string, unknown> = {};
+		for (const [key, value] of options.annotations) {
+			annotations[key] = value;
+		}
+		entries.push({
+			message: EffectArray.ensure(options.message).join(' '),
+			logLevel: options.logLevel,
+			annotations,
+		});
+	});
+
+	const layer = Layer.merge(
+		EffectLogger.replace(EffectLogger.defaultLogger, logger),
+		EffectLogger.minimumLogLevel(LogLevel.All),
+	);
+
+	return { entries, layer };
+}
+
+describe('Logger.sync', () => {
+	it.effect('logs without annotations', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync().pipe(Effect.provide(layer));
+			log.info('hello');
+			yield* Effect.yieldNow();
+			expect(entries).toHaveLength(1);
+			expect(entries[0].message).toBe('hello');
+			expect(entries[0].annotations).toEqual({});
+		}),
+	);
+
+	it.effect('initial annotations from sync()', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync({ service: 'api' }).pipe(
+				Effect.provide(layer),
+			);
+			log.info('started');
+			yield* Effect.yieldNow();
+			expect(entries[0].annotations).toEqual({ service: 'api' });
+		}),
+	);
+
+	it.effect('.child() adds annotations', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync().pipe(Effect.provide(layer));
+			const child = log.child({ requestId: '123' });
+			child.info('handled');
+			yield* Effect.yieldNow();
+			expect(entries[0].annotations).toEqual({ requestId: '123' });
+		}),
+	);
+
+	it.effect('.child() merges parent + child annotations', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync({ service: 'api' }).pipe(
+				Effect.provide(layer),
+			);
+			const child = log.child({ requestId: '123' });
+			child.info('handled');
+			yield* Effect.yieldNow();
+			expect(entries[0].annotations).toEqual({
+				service: 'api',
+				requestId: '123',
+			});
+		}),
+	);
+
+	it.effect('.child() overrides parent on key conflict', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync({ env: 'dev' }).pipe(
+				Effect.provide(layer),
+			);
+			const child = log.child({ env: 'prod' });
+			child.info('test');
+			yield* Effect.yieldNow();
+			expect(entries[0].annotations).toEqual({ env: 'prod' });
+		}),
+	);
+
+	it.effect('chained .child().child() accumulates annotations', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync({ a: 1 }).pipe(Effect.provide(layer));
+			const grandchild = log.child({ b: 2 }).child({ c: 3 });
+			grandchild.info('deep');
+			yield* Effect.yieldNow();
+			expect(entries[0].annotations).toEqual({ a: 1, b: 2, c: 3 });
+		}),
+	);
+
+	it.effect('parent unaffected by child creation', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const parent = yield* Logger.sync({ service: 'api' }).pipe(
+				Effect.provide(layer),
+			);
+			parent.child({ requestId: '123' });
+			parent.info('still parent');
+			yield* Effect.yieldNow();
+			expect(entries[0].annotations).toEqual({ service: 'api' });
+		}),
+	);
+
+	it.effect('all log levels work on child', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync().pipe(Effect.provide(layer));
+			const child = log.child({ ctx: 'test' });
+			child.info('i');
+			child.debug('d');
+			child.warn('w');
+			child.error('e');
+			yield* Effect.yieldNow();
+			expect(entries).toHaveLength(4);
+			expect(entries[0].logLevel).toBe(LogLevel.Info);
+			expect(entries[1].logLevel).toBe(LogLevel.Debug);
+			expect(entries[2].logLevel).toBe(LogLevel.Warning);
+			expect(entries[3].logLevel).toBe(LogLevel.Error);
+			for (const entry of entries) {
+				expect(entry.annotations).toEqual({ ctx: 'test' });
+			}
+		}),
+	);
+
+	it.effect('per-call attributes merge with persistent annotations', () =>
+		Effect.gen(function* () {
+			const { entries, layer } = makeTestLogger();
+			const log = yield* Logger.sync({ service: 'api' }).pipe(
+				Effect.provide(layer),
+			);
+			const child = log.child({ requestId: '123' });
+			child.info({ extra: 'val' }, 'with attrs');
+			yield* Effect.yieldNow();
+			expect(entries[0].message).toBe('with attrs');
+			expect(entries[0].annotations).toEqual({
+				service: 'api',
+				requestId: '123',
+				extra: 'val',
+			});
+		}),
+	);
+});

package/src/logger.ts

@@ -1,34 +1,56 @@
-import { Effect, FiberSet, Runtime } from 'effect';
+import { Effect, Runtime } from 'effect';
 
 type LogParams = [obj: unknown, msg?: string];
 function extractParams(...[obj, msg]: LogParams) {
 	if (typeof obj === 'string') {
 		return { message: obj };
 	}
+	// biome-ignore lint/suspicious/noExplicitAny: log attributes are unstructured
 	return { message: msg, attributes: obj as Record<string, any> };
 }
 
+// biome-ignore lint/suspicious/noExplicitAny: log annotations are unstructured
+type LogAnnotations = Record<string, any>;
+
+export type SyncLogger = {
+	info: (...params: Parameters<typeof Logger.info>) => void;
+	debug: (...params: Parameters<typeof Logger.debug>) => void;
+	warn: (...params: Parameters<typeof Logger.warn>) => void;
+	error: (...params: Parameters<typeof Logger.error>) => void;
+	child: (annotations: LogAnnotations) => SyncLogger;
+};
+
+function makeSyncLogger(
+	runtime: Runtime.Runtime<never>,
+	annotations: LogAnnotations,
+): SyncLogger {
+	const run = (e: Effect.Effect<void, never, never>) => {
+		const annotated =
+			Object.keys(annotations).length > 0
+				? e.pipe(Effect.annotateLogs(annotations))
+				: e;
+		void Runtime.runPromise(runtime)(annotated);
+	};
+
+	return {
+		info: (...params: Parameters<typeof Logger.info>) =>
+			run(Logger.info(...params)),
+		debug: (...params: Parameters<typeof Logger.debug>) =>
+			run(Logger.debug(...params)),
+		warn: (...params: Parameters<typeof Logger.warn>) =>
+			run(Logger.warn(...params)),
+		error: (...params: Parameters<typeof Logger.error>) =>
+			run(Logger.error(...params)),
+		child: (childAnnotations: LogAnnotations) =>
+			makeSyncLogger(runtime, { ...annotations, ...childAnnotations }),
+	};
+}
+
 export namespace Logger {
-	export const sync = () =>
+	export const sync = (annotations?: LogAnnotations) =>
 		Effect.gen(function* () {
 			const runtime = yield* Effect.runtime();
-
-			const run = (e: Effect.Effect<void, never, never>) => {
-				// Intentionally ignoring the await here
-				// void runPromise(e);
-				void Runtime.runPromise(runtime)(e);
-			};
-
-			return {
-				info: (...params: Parameters<typeof Logger.info>) =>
-					run(Logger.info(...params)),
-				debug: (...params: Parameters<typeof Logger.debug>) =>
-					run(Logger.debug(...params)),
-				warn: (...params: Parameters<typeof Logger.warn>) =>
-					run(Logger.warn(...params)),
-				error: (...params: Parameters<typeof Logger.error>) =>
-					run(Logger.error(...params)),
-			};
+			return makeSyncLogger(runtime, annotations ?? {});
 		});
 
 	// --