effect-start 0.22.0 → 0.23.0

package/dist/lint/plugin.js

@@ -0,0 +1,341 @@
+/**
+ * @see https://oxc.rs/docs/guide/usage/linter/js-plugins.html#using-js-plugins
+ */
+const forceNamespace = new Set(["bun:test"]);
+export default {
+    meta: {
+        name: "effect-start",
+        version: "0.1.0",
+    },
+    rules: {
+        "prefer-namespace-import": {
+            meta: {
+                type: "suggestion",
+                docs: {
+                    description: "Enforce namespace imports for modules with capitalized base names or specific forced modules",
+                },
+                fixable: "code",
+                hasSuggestions: true,
+                schema: [],
+                messages: {
+                    preferNamespace: 'Use namespace import for module "{{source}}": import {{typePrefix}}* as {{baseName}} from "{{source}}"',
+                },
+            },
+            create(context) {
+                return {
+                    ImportDeclaration(node) {
+                        const source = node.source.value;
+                        if (typeof source !== "string")
+                            return;
+                        const baseName = getBaseName(source);
+                        if (!baseName)
+                            return;
+                        const forced = forceNamespace.has(source);
+                        if (!forced && !isCapitalized(baseName))
+                            return;
+                        // Already a namespace import (with or without type-only)
+                        if (node.specifiers.length === 1 &&
+                            node.specifiers[0].type === "ImportNamespaceSpecifier") {
+                            return;
+                        }
+                        // Skip if there are no specifiers (side-effect import)
+                        if (node.specifiers.length === 0)
+                            return;
+                        // Skip if it's only a default import (not applicable for forced modules)
+                        if (!forced) {
+                            const hasNamedImports = node.specifiers.some((s) => s.type === "ImportSpecifier");
+                            if (!hasNamedImports)
+                                return;
+                        }
+                        const typePrefix = node.importKind === "type" ? "type " : "";
+                        context.report({
+                            node,
+                            messageId: "preferNamespace",
+                            data: { source, baseName, typePrefix },
+                            fix(fixer) {
+                                return fixer.replaceText(node, `import ${typePrefix}* as ${baseName} from "${source}"`);
+                            },
+                        });
+                    },
+                };
+            },
+        },
+        "test-space-around": {
+            meta: {
+                type: "layout",
+                docs: {
+                    description: "Enforce blank lines around test calls (test.describe, test.it, etc.)",
+                },
+                fixable: "whitespace",
+                schema: [],
+                messages: {
+                    requireBlankBefore: "Test call should be preceded by a blank line",
+                    requireBlankAfter: "Test call should be followed by a blank line",
+                },
+            },
+            create(context) {
+                const filename = context.filename || context.getFilename();
+                if (!filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx")) {
+                    return {};
+                }
+                function isTestCall(node) {
+                    return (node &&
+                        node.type === "ExpressionStatement" &&
+                        node.expression.type === "CallExpression" &&
+                        node.expression.callee.type === "MemberExpression" &&
+                        node.expression.callee.object.type === "Identifier" &&
+                        node.expression.callee.object.name === "test");
+                }
+                function checkBlankLines(siblings) {
+                    const sourceCode = context.sourceCode || context.getSourceCode();
+                    for (let i = 0; i < siblings.length; i++) {
+                        const node = siblings[i];
+                        if (!isTestCall(node))
+                            continue;
+                        const prev = siblings[i - 1];
+                        const next = siblings[i + 1];
+                        if (prev) {
+                            if (node.loc.start.line - prev.loc.end.line < 2) {
+                                context.report({
+                                    node,
+                                    messageId: "requireBlankBefore",
+                                    fix(fixer) {
+                                        return fixer.insertTextAfter(sourceCode.getLastToken(prev), "\n");
+                                    },
+                                });
+                            }
+                        }
+                        if (next) {
+                            if (next.loc.start.line - node.loc.end.line < 2) {
+                                context.report({
+                                    node,
+                                    messageId: "requireBlankAfter",
+                                    fix(fixer) {
+                                        return fixer.insertTextAfter(sourceCode.getLastToken(node), "\n");
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+                return {
+                    Program(node) {
+                        checkBlankLines(node.body);
+                    },
+                    BlockStatement(node) {
+                        checkBlankLines(node.body);
+                    },
+                };
+            },
+        },
+        // this doens't work reliably and may cause runtime errors
+        "export-default-before-functions": {
+            meta: {
+                type: "suggestion",
+                docs: {
+                    description: "Enforce export default appears before any function declarations",
+                },
+                schema: [],
+                messages: {
+                    defaultAfterFunction: "export default should appear before function declarations",
+                },
+            },
+            create(context) {
+                return {
+                    Program(node) {
+                        let seenFunction = false;
+                        for (const stmt of node.body) {
+                            if (!seenFunction && isFunction(stmt)) {
+                                seenFunction = true;
+                            }
+                            if (seenFunction && stmt.type === "ExportDefaultDeclaration") {
+                                context.report({
+                                    node: stmt,
+                                    messageId: "defaultAfterFunction",
+                                });
+                            }
+                        }
+                    },
+                };
+            },
+        },
+        "test-assertion-newline": {
+            meta: {
+                type: "layout",
+                docs: {
+                    description: "Enforce newlines between chained test assertion methods (test.expect().toBe())",
+                },
+                fixable: "whitespace",
+                schema: [],
+                messages: {
+                    requireNewline: "Each chained method in a test assertion should be on its own line",
+                    requireBlankBefore: "Test assertion should be preceded by an empty line (unless preceded by another assertion)",
+                    requireBlankAfter: "Test assertion should be followed by an empty line (unless followed by another assertion)",
+                },
+            },
+            create(context) {
+                const filename = context.filename || context.getFilename();
+                if (!filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx")) {
+                    return {};
+                }
+                /**
+                 * Check if a call expression is rooted in test.expect or test.expectTypeOf
+                 */
+                function isTestAssertionChain(node) {
+                    let current = node;
+                    while (current) {
+                        if (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+                            const obj = current.callee.object;
+                            // Check for test.expect(...) or test.expectTypeOf(...)
+                            if (obj.type === "CallExpression" &&
+                                obj.callee.type === "MemberExpression" &&
+                                obj.callee.object.type === "Identifier" &&
+                                obj.callee.object.name === "test" &&
+                                obj.callee.property.type === "Identifier" &&
+                                (obj.callee.property.name === "expect" ||
+                                    obj.callee.property.name === "expectTypeOf")) {
+                                return true;
+                            }
+                            // Direct: test.expect(...) or test.expectTypeOf(...)
+                            if (current.callee.object.type === "Identifier" &&
+                                current.callee.object.name === "test" &&
+                                current.callee.property.type === "Identifier" &&
+                                (current.callee.property.name === "expect" ||
+                                    current.callee.property.name === "expectTypeOf")) {
+                                return true;
+                            }
+                            // Walk up the chain
+                            current = current.callee.object;
+                            continue;
+                        }
+                        // Handle non-call member access like .not
+                        if (current.type === "MemberExpression") {
+                            current = current.object;
+                            continue;
+                        }
+                        break;
+                    }
+                    return false;
+                }
+                /**
+                 * Collect all member expressions in a chained call.
+                 */
+                function getChainedMembers(node) {
+                    const members = [];
+                    let current = node;
+                    while (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+                        members.push(current.callee);
+                        current = current.callee.object;
+                    }
+                    return members;
+                }
+                function isAssertionStatement(stmt) {
+                    return (stmt &&
+                        stmt.type === "ExpressionStatement" &&
+                        stmt.expression.type === "CallExpression" &&
+                        isTestAssertionChain(stmt.expression));
+                }
+                function checkChainedNewlines(node) {
+                    const members = getChainedMembers(node.expression);
+                    for (const member of members) {
+                        const objectEndLine = member.object.loc.end.line;
+                        const propertyStartLine = member.property.loc.start.line;
+                        if (objectEndLine === propertyStartLine) {
+                            const sourceCode = context.sourceCode || context.getSourceCode();
+                            const dot = sourceCode.getTokenBefore(member.property);
+                            if (dot && dot.value === ".") {
+                                context.report({
+                                    node: member.property,
+                                    messageId: "requireNewline",
+                                    fix(fixer) {
+                                        const stmtStartCol = node.loc.start.column;
+                                        const indent = " ".repeat(stmtStartCol + 2);
+                                        return fixer.replaceTextRange([member.object.range[1], member.property.range[0]], "\n" + indent + ".");
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+                function checkBlankLines(siblings) {
+                    const sourceCode = context.sourceCode || context.getSourceCode();
+                    for (let i = 0; i < siblings.length; i++) {
+                        const node = siblings[i];
+                        if (!isAssertionStatement(node))
+                            continue;
+                        const prev = siblings[i - 1];
+                        const next = siblings[i + 1];
+                        if (prev && !isAssertionStatement(prev)) {
+                            if (node.loc.start.line - prev.loc.end.line < 2) {
+                                context.report({
+                                    node,
+                                    messageId: "requireBlankBefore",
+                                    fix(fixer) {
+                                        return fixer.insertTextAfter(sourceCode.getLastToken(prev), "\n");
+                                    },
+                                });
+                            }
+                        }
+                        if (next && !isAssertionStatement(next)) {
+                            if (next.loc.start.line - node.loc.end.line < 2) {
+                                context.report({
+                                    node,
+                                    messageId: "requireBlankAfter",
+                                    fix(fixer) {
+                                        return fixer.insertTextAfter(sourceCode.getLastToken(node), "\n");
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+                return {
+                    ExpressionStatement(node) {
+                        if (node.expression.type !== "CallExpression")
+                            return;
+                        if (!isTestAssertionChain(node.expression))
+                            return;
+                        checkChainedNewlines(node);
+                    },
+                    Program(node) {
+                        checkBlankLines(node.body);
+                    },
+                    BlockStatement(node) {
+                        checkBlankLines(node.body);
+                    },
+                };
+            },
+        },
+    },
+};
+function getBaseName(source) {
+    // Handle node: and bun: protocols
+    if (source.startsWith("node:")) {
+        return source.slice(5);
+    }
+    if (source.startsWith("bun:")) {
+        return source.slice(4);
+    }
+    // Get last path segment
+    const segments = source.split("/");
+    let last = segments[segments.length - 1];
+    // Strip file extension (.ts, .tsx, .js, .jsx, .mjs, .cjs)
+    last = last.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+    return last;
+}
+function isCapitalized(name) {
+    return name.length > 0 && name[0] >= "A" && name[0] <= "Z";
+}
+function isFunction(stmt) {
+    const decl = stmt.type === "ExportNamedDeclaration" && stmt.declaration ? stmt.declaration : stmt;
+    if (decl.type === "FunctionDeclaration")
+        return true;
+    if (decl.type === "VariableDeclaration" &&
+        decl.declarations.length > 0 &&
+        decl.declarations[0].init &&
+        (decl.declarations[0].init.type === "ArrowFunctionExpression" ||
+            decl.declarations[0].init.type === "FunctionExpression")) {
+        return true;
+    }
+    return false;
+}

package/dist/node/NodeFileSystem.d.ts

@@ -1,7 +1,7 @@
-import * as FileSystem from "@effect/platform/FileSystem";
 import * as Layer from "effect/Layer";
+import * as FileSystem from "../FileSystem.ts";
 import * as NFS from "node:fs";
 import * as PlatformError from "../PlatformError.ts";
 export declare const layer: Layer.Layer<FileSystem.FileSystem, never, never>;
-export { FileSystem, PlatformError as Error, };
+export { PlatformError as Error };
 export declare function handleErrnoException(module: PlatformError.SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError.PlatformError;

package/dist/node/NodeFileSystem.js

@@ -1,11 +1,8 @@
-/*
- * Adapted from @effect/platform
- */
-import * as FileSystem from "@effect/platform/FileSystem";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as FileSystem from "../FileSystem.js";
 import * as Stream from "effect/Stream";
 import * as NCrypto from "node:crypto";
 import * as NFS from "node:fs";
@@ -66,9 +63,7 @@ const makeTempDirectoryFactory = (method) => {
     const nodeMkdtemp = Effectify.effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(method));
     return (options) => Effect.suspend(() => {
         const prefix = options?.prefix ?? "";
-        const directory = typeof options?.directory === "string"
-            ? NPath.join(options.directory, ".")
-            : NOS.tmpdir();
+        const directory = typeof options?.directory === "string" ? NPath.join(options.directory, ".") : NOS.tmpdir();
         return nodeMkdtemp(prefix ? NPath.join(directory, prefix) : directory + "/");
     });
 };
@@ -374,13 +369,8 @@ const make = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend)
     },
     writeFile,
 }));
-export const layer = Layer.unwrapEffect(Effect
-    .gen(function* () {
-    const mod = yield* Effect.tryPromise(() => import("@effect/platform/FileSystem"));
-    return Layer.effect(mod.FileSystem, make);
-})
-    .pipe(Effect.catchAll(() => Effect.die(new globalThis.Error("@effect/platform is not installed")))));
-export { FileSystem, PlatformError as Error, };
+export const layer = Layer.effect(FileSystem.FileSystem, make);
+export { PlatformError as Error };
 export function handleErrnoException(module, method) {
     return function (err, [path]) {
         let reason = "Unknown";

package/dist/sql/bun/index.d.ts

@@ -0,0 +1,3 @@
+import * as Layer from "effect/Layer";
+import * as Sql from "../../Sql.ts";
+export declare const layer: (config: ConstructorParameters<typeof Bun.SQL>[0]) => Layer.Layer<Sql.SqlClient, Sql.SqlError>;

package/dist/sql/bun/index.js

@@ -0,0 +1,75 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FiberRef from "effect/FiberRef";
+import * as GlobalValue from "effect/GlobalValue";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Sql from "../../Sql.js";
+const errorCode = (error) => {
+    const e = error;
+    if (typeof e?.errno === "string")
+        return e.errno;
+    return e?.code ?? "UNKNOWN";
+};
+const wrapError = (error) => new Sql.SqlError({
+    code: errorCode(error),
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+});
+const wrap = (fn) => Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError });
+const makeValues = (obj, ...columns) => {
+    const items = Array.isArray(obj) ? obj : [obj];
+    const cols = columns.length > 0 ? columns : Object.keys(items[0]);
+    return { value: items, columns: cols };
+};
+const currentTransaction = GlobalValue.globalValue(Symbol.for("effect-start/sql/bun/currentTransaction"), () => FiberRef.unsafeMake(Option.none()));
+const makeRun = (bunSql) => (fn) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => wrap(() => fn(Option.isSome(txOpt) ? txOpt.value.conn : bunSql)));
+const makeWithTransaction = (bunSql) => (self) => Effect.uninterruptibleMask((restore) => Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    if (Option.isSome(txOpt)) {
+        const { conn, depth } = txOpt.value;
+        const name = `sp_${depth}`;
+        return Effect.gen(function* () {
+            yield* wrap(() => conn.unsafe(`SAVEPOINT ${name}`));
+            const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: depth + 1 }))));
+            if (Exit.isSuccess(exit)) {
+                yield* wrap(() => conn.unsafe(`RELEASE SAVEPOINT ${name}`));
+                return exit.value;
+            }
+            yield* wrap(() => conn.unsafe(`ROLLBACK TO SAVEPOINT ${name}`)).pipe(Effect.orDie);
+            return yield* exit;
+        });
+    }
+    const runTx = (conn) => Effect.gen(function* () {
+        yield* wrap(() => conn.unsafe("BEGIN"));
+        const exit = yield* Effect.exit(restore(Effect.locally(self, currentTransaction, Option.some({ conn, depth: 1 }))));
+        if (Exit.isSuccess(exit)) {
+            yield* wrap(() => conn.unsafe("COMMIT"));
+            return exit.value;
+        }
+        yield* wrap(() => conn.unsafe("ROLLBACK")).pipe(Effect.orDie);
+        return yield* exit;
+    });
+    return Effect.matchEffect(wrap(() => bunSql.reserve()), {
+        onFailure: () => runTx(bunSql),
+        onSuccess: (reserved) => Effect.ensuring(runTx(reserved), Effect.sync(() => reserved.release())),
+    });
+}));
+export const layer = (config) => Layer.scoped(Sql.SqlClient, Effect.acquireRelease(Effect.try({
+    try: () => {
+        const bunSql = new Bun.SQL(config);
+        const run = makeRun(bunSql);
+        const use = (fn) => Effect.tryPromise({ try: () => Promise.resolve(fn(bunSql)), catch: wrapError });
+        return Object.assign((strings, ...values) => run((conn) => conn(strings, ...values)), {
+            unsafe: (query, values) => run((conn) => conn.unsafe(query, values)),
+            values: makeValues,
+            withTransaction: makeWithTransaction(bunSql),
+            reserve: Effect.acquireRelease(wrap(() => bunSql.reserve()), (reserved) => Effect.sync(() => reserved.release())).pipe(Effect.map((reserved) => Object.assign((strings, ...values) => wrap(() => reserved(strings, ...values)), {
+                unsafe: (query, values) => wrap(() => reserved.unsafe(query, values)),
+                values: makeValues,
+            }))),
+            close: (options) => use((bunSql) => bunSql.close(options)),
+            use,
+        });
+    },
+    catch: wrapError,
+}), (client) => client.close().pipe(Effect.orDie)));

package/dist/sql/mssql/docker.d.ts

@@ -0,0 +1,2 @@
+export declare const start: () => Promise<void>;
+export declare const stop: () => Promise<void>;

package/dist/sql/mssql/docker.js

@@ -0,0 +1,67 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as System from "../../System.js";
+import * as BunChildProcessSpawner from "../../bun/BunChildProcessSpawner.js";
+const PORT = 1433;
+const PASSWORD = "TestPass123";
+const CONTAINER = "effect-start-mssql";
+const exec = (...args) => Effect.scoped(Effect.gen(function* () {
+    const handle = yield* System.spawn("docker", args, {
+        stdout: "ignore",
+        stderr: "inherit",
+    });
+    return yield* handle.exitCode;
+}));
+const execStdout = (...args) => Effect.scoped(Effect.gen(function* () {
+    const handle = yield* System.spawn("docker", args, {
+        stdout: "pipe",
+        stderr: "inherit",
+    });
+    const [stdout] = yield* Effect.all([handle.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString), handle.exitCode], { concurrency: 2 });
+    return stdout;
+}));
+const containerRunning = execStdout("ps", "-q", "-f", `name=${CONTAINER}`).pipe(Effect.map((stdout) => stdout.trim().length > 0));
+const removeContainer = exec("rm", "-f", CONTAINER).pipe(Effect.ignore);
+const loadMssql = () => import("mssql");
+const canConnect = Effect.tryPromise({
+    try: async () => {
+        const { ConnectionPool } = await loadMssql();
+        const pool = new ConnectionPool({
+            server: "localhost",
+            user: "sa",
+            password: PASSWORD,
+            port: PORT,
+            options: { encrypt: true, trustServerCertificate: true, connectTimeout: 3000 },
+        });
+        await pool.connect();
+        await pool.close();
+        return true;
+    },
+    catch: () => false,
+}).pipe(Effect.orElseSucceed(() => false));
+const waitReady = Effect.gen(function* () {
+    const deadline = Date.now() + 60_000;
+    while (Date.now() < deadline) {
+        if (yield* canConnect)
+            return;
+        yield* Effect.sleep("2 seconds");
+    }
+    return yield* Effect.fail(new Error("Timed out waiting for MSSQL"));
+});
+const program = Effect.gen(function* () {
+    if (yield* containerRunning) {
+        yield* Effect.log("MSSQL container already running");
+        return;
+    }
+    yield* removeContainer;
+    yield* Effect.log("Starting MSSQL container...");
+    const code = yield* exec("run", "-d", "--name", CONTAINER, "-p", `${PORT}:1433`, "-e", "ACCEPT_EULA=Y", "-e", `MSSQL_SA_PASSWORD=${PASSWORD}`, "mcr.microsoft.com/azure-sql-edge");
+    if (code !== 0) {
+        return yield* Effect.fail(new Error(`docker run exited with code ${code}`));
+    }
+    yield* waitReady;
+    yield* Effect.log("MSSQL ready");
+});
+const run = (effect) => Effect.runPromise(Effect.provide(effect, BunChildProcessSpawner.layer));
+export const start = () => run(program);
+export const stop = () => run(removeContainer);

package/dist/sql/mssql/index.d.ts

@@ -0,0 +1,21 @@
+import * as Layer from "effect/Layer";
+import * as Sql from "../../Sql.ts";
+export interface MssqlConfig {
+    readonly server: string;
+    readonly database?: string;
+    readonly user?: string;
+    readonly password?: string;
+    readonly port?: number;
+    readonly pool?: {
+        readonly max?: number;
+        readonly min?: number;
+        readonly idleTimeoutMillis?: number;
+    };
+    readonly options?: {
+        readonly encrypt?: boolean;
+        readonly trustServerCertificate?: boolean;
+        readonly requestTimeout?: number;
+        readonly connectionTimeout?: number;
+    };
+}
+export declare const layer: (config: MssqlConfig) => Layer.Layer<Sql.SqlClient, Sql.SqlError>;