effect-start 0.27.0 → 0.29.0

package/src/lint/plugin.js

@@ -9,19 +9,19 @@ export default {
     version: "0.1.0",
   },
   rules: {
-    "prefer-namespace-import": {
+    "namespace-import": {
       meta: {
         type: "suggestion",
         docs: {
           description:
-            "Enforce namespace imports for modules with capitalized base names or specific forced modules",
+            "Enforce namespace imports with matching aliases for capitalized modules and specific forced modules",
         },
-        fixable: "code",
-        hasSuggestions: true,
         schema: [],
         messages: {
           preferNamespace:
-            'Use namespace import for module "{{source}}": import {{typePrefix}}* as {{baseName}} from "{{source}}"',
+            'Use namespace import for module "{{source}}": import * as {{baseName}} from "{{source}}"',
+          mismatch:
+            'Namespace import alias "{{alias}}" does not match module basename "{{baseName}}"',
         },
       },
       create(context) {
@@ -36,61 +36,33 @@ export default {
             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"
-            ) {
+            const isNamespace =
+              node.specifiers.length === 1 && node.specifiers[0].type === "ImportNamespaceSpecifier"
+
+            if (isNamespace) {
+              if (!isLocalImport(source)) return
+              const alias = node.specifiers[0].local.name
+              if (alias === baseName) return
+
+              context.report({
+                node,
+                messageId: "mismatch",
+                data: { alias, baseName },
+              })
               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 " : ""
-
-            const sourceCode = context.sourceCode || context.getSourceCode()
-
             context.report({
               node,
               messageId: "preferNamespace",
-              data: { source, baseName, typePrefix },
-              fix(fixer) {
-                const fixes = [
-                  fixer.replaceText(
-                    node,
-                    `import ${typePrefix}* as ${baseName} from "${source}"`,
-                  ),
-                ]
-
-                for (const specifier of node.specifiers) {
-                  if (specifier.type !== "ImportSpecifier") continue
-                  const localName = specifier.local.name
-                  const importedName = specifier.imported.name
-
-                  for (const variable of sourceCode.getDeclaredVariables(specifier)) {
-                    for (const ref of variable.references) {
-                      if (ref.identifier.range[0] === specifier.local.range[0]) continue
-                      fixes.push(
-                        fixer.replaceTextRange(
-                          ref.identifier.range,
-                          localName !== importedName
-                            ? `${baseName}.${importedName}`
-                            : `${baseName}.${localName}`,
-                        ),
-                      )
-                    }
-                  }
-                }
-
-                return fixes
-              },
+              data: { source, baseName },
             })
           },
         }
@@ -243,18 +215,15 @@ export default {
           const ancestors = sourceCode.getAncestors(node)
           const parent = ancestors[ancestors.length - 1]
           if (!parent) return false
-          if (parent.type === "MethodDefinition" || parent.type === "Property" && parent.method) return true
-          if (
-            parent.type === "VariableDeclarator" &&
-            parent.init === node
-          ) return true
+          if (parent.type === "MethodDefinition" || (parent.type === "Property" && parent.method))
+            return true
+          if (parent.type === "VariableDeclarator" && parent.init === node) return true
           return false
         }
 
         function checkParams(node) {
           for (const param of node.params) {
-            const pattern =
-              param.type === "AssignmentPattern" ? param.left : param
+            const pattern = param.type === "AssignmentPattern" ? param.left : param
             if (pattern.type !== "ObjectPattern") continue
 
             const baseName = isDefinition(node) ? "options" : "v"
@@ -262,84 +231,77 @@ export default {
             const name = findUnusedName(outerScope, baseName)
 
             const hasPropertyDefaults = pattern.properties.some(
-              (prop) =>
-                prop.type !== "RestElement" &&
-                prop.value.type === "AssignmentPattern",
+              (prop) => prop.type !== "RestElement" && prop.value.type === "AssignmentPattern",
             )
 
             context.report({
               node: pattern,
               messageId: "noDestructuredParam",
-              fix: hasPropertyDefaults ? undefined : (fixer) => {
-                const fixes = []
-
-                const typeAnnotation = pattern.typeAnnotation
-                  ? sourceCode.getText(pattern.typeAnnotation)
-                  : ""
-                const hasDefault = param.type === "AssignmentPattern"
-                const defaultValue = hasDefault
-                  ? " = " + sourceCode.getText(param.right)
-                  : ""
-
-                fixes.push(
-                  fixer.replaceTextRange(
-                    param.range,
-                    name + typeAnnotation + defaultValue,
-                  ),
-                )
-
-                const fnScope = sourceCode.getScope(node)
-                const localToKey = new Map()
-                for (const prop of pattern.properties) {
-                  if (prop.type === "RestElement") continue
-                  const keyName =
-                    prop.key.type === "Identifier"
-                      ? prop.key.name
-                      : sourceCode.getText(prop.key)
-                  const localNode =
-                    prop.value.type === "AssignmentPattern"
-                      ? prop.value.left
-                      : prop.value
-                  if (localNode.type === "Identifier") {
-                    localToKey.set(localNode.name, keyName)
-                  }
-                }
-
-                for (const variable of fnScope.variables) {
-                  const keyName = localToKey.get(variable.name)
-                  if (keyName === undefined) continue
-
-                  for (const ref of variable.references) {
-                    if (ref.identifier.range[0] >= pattern.range[0] &&
-                        ref.identifier.range[1] <= pattern.range[1]) continue
-
-                    const ancestors = sourceCode.getAncestors(ref.identifier)
-                    const parent = ancestors[ancestors.length - 1]
-                    if (
-                      parent &&
-                      parent.type === "Property" &&
-                      parent.shorthand &&
-                      parent.value === ref.identifier
-                    ) {
-                      fixes.push(
-                        fixer.replaceTextRange(
-                          parent.range,
-                          keyName + ": " + name + "." + keyName,
-                        ),
-                      )
-                    } else {
-                      fixes.push(
-                        fixer.replaceTextRange(
-                          ref.identifier.range,
-                          name + "." + keyName,
-                        ),
-                      )
+              fix: hasPropertyDefaults
+                ? undefined
+                : (fixer) => {
+                    const fixes = []
+
+                    const typeAnnotation = pattern.typeAnnotation
+                      ? sourceCode.getText(pattern.typeAnnotation)
+                      : ""
+                    const hasDefault = param.type === "AssignmentPattern"
+                    const defaultValue = hasDefault ? " = " + sourceCode.getText(param.right) : ""
+
+                    fixes.push(
+                      fixer.replaceTextRange(param.range, name + typeAnnotation + defaultValue),
+                    )
+
+                    const fnScope = sourceCode.getScope(node)
+                    const localToKey = new Map()
+                    for (const prop of pattern.properties) {
+                      if (prop.type === "RestElement") continue
+                      const keyName =
+                        prop.key.type === "Identifier"
+                          ? prop.key.name
+                          : sourceCode.getText(prop.key)
+                      const localNode =
+                        prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value
+                      if (localNode.type === "Identifier") {
+                        localToKey.set(localNode.name, keyName)
+                      }
                     }
-                  }
-                }
 
-                return fixes
-              },
+                    for (const variable of fnScope.variables) {
+                      const keyName = localToKey.get(variable.name)
+                      if (keyName === undefined) continue
+
+                      for (const ref of variable.references) {
+                        if (
+                          ref.identifier.range[0] >= pattern.range[0] &&
+                          ref.identifier.range[1] <= pattern.range[1]
+                        )
+                          continue
+
+                        const ancestors = sourceCode.getAncestors(ref.identifier)
+                        const parent = ancestors[ancestors.length - 1]
+                        if (
+                          parent &&
+                          parent.type === "Property" &&
+                          parent.shorthand &&
+                          parent.value === ref.identifier
+                        ) {
+                          fixes.push(
+                            fixer.replaceTextRange(
+                              parent.range,
+                              keyName + ": " + name + "." + keyName,
+                            ),
+                          )
+                        } else {
+                          fixes.push(
+                            fixer.replaceTextRange(ref.identifier.range, name + "." + keyName),
+                          )
+                        }
+                      }
+                    }
+
+                    return fixes
+                  },
             })
           }
         }
@@ -352,6 +314,90 @@ export default {
       },
     },
 
+    "test-effects": {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description:
+            "Disallow await Effect.runPromise(...) in test callbacks. Use Effect.gen(...).pipe(Effect.runPromise) as the return value instead.",
+        },
+        schema: [],
+        messages: {
+          noAwaitRunPromise:
+            "Avoid Effect.runPromise in async test callbacks. Use () => Effect.gen(function*() { ... }).pipe(Effect.runPromise) instead.",
+          scopedWrapping: "Use .pipe(Effect.scoped) instead of Effect.scoped(...) wrapping.",
+        },
+      },
+      create(context) {
+        const filename = context.filename || context.getFilename()
+        if (!filename.endsWith(".test.ts") && !filename.endsWith(".test.tsx")) {
+          return {}
+        }
+
+        function isTestCallback(node) {
+          const sourceCode = context.sourceCode || context.getSourceCode()
+          const ancestors = sourceCode.getAncestors(node)
+          const parent = ancestors[ancestors.length - 1]
+          if (!parent || parent.type !== "CallExpression") return false
+          const callee = parent.callee
+          return (
+            callee.type === "MemberExpression" &&
+            callee.object.type === "Identifier" &&
+            callee.object.name === "test" &&
+            callee.property.type === "Identifier" &&
+            (callee.property.name === "it" || callee.property.name === "test")
+          )
+        }
+
+        function findEnclosingAsyncTestCallback(node) {
+          const sourceCode = context.sourceCode || context.getSourceCode()
+          const ancestors = sourceCode.getAncestors(node)
+          for (let i = ancestors.length - 1; i >= 0; i--) {
+            const ancestor = ancestors[i]
+            if (
+              (ancestor.type === "ArrowFunctionExpression" ||
+                ancestor.type === "FunctionExpression") &&
+              ancestor.async
+            ) {
+              return isTestCallback(ancestor) ? ancestor : undefined
+            }
+          }
+        }
+
+        return {
+          CallExpression(node) {
+            if (
+              node.callee.type === "MemberExpression" &&
+              node.callee.object.type === "Identifier" &&
+              node.callee.object.name === "Effect" &&
+              node.callee.property.type === "Identifier" &&
+              node.callee.property.name === "scoped" &&
+              node.arguments.length === 1
+            ) {
+              context.report({
+                node,
+                messageId: "scopedWrapping",
+              })
+            }
+          },
+          MemberExpression(node) {
+            if (
+              node.object.type === "Identifier" &&
+              node.object.name === "Effect" &&
+              node.property.type === "Identifier" &&
+              node.property.name === "runPromise" &&
+              findEnclosingAsyncTestCallback(node)
+            ) {
+              context.report({
+                node,
+                messageId: "noAwaitRunPromise",
+              })
+            }
+          },
+        }
+      },
+    },
+
     "test-assertion-newline": {
       meta: {
         type: "layout",
@@ -549,10 +595,18 @@ function getBaseName(source) {
   // Strip file extension (.ts, .tsx, .js, .jsx, .mjs, .cjs)
   last = last.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "")
 
+  // Strip leading underscores (private module convention)
+  last = last.replace(/^_+/, "")
+
   return last
 }
 
+function isLocalImport(source) {
+  return source.startsWith(".") || source.startsWith("/")
+}
+
 function isCapitalized(name) {
+  if (name.length > 0 && name[0] === "_") return isCapitalized(name.slice(1))
   return name.length > 0 && name[0] >= "A" && name[0] <= "Z"
 }
 

package/src/node/NodeFileSystem.ts

@@ -12,11 +12,12 @@ import * as NCrypto from "node:crypto"
 import * as NFS from "node:fs"
 import * as NOS from "node:os"
 import * as NPath from "node:path"
-import * as PlatformError from "../PlatformError.ts"
-import * as Effectify from "../Effectify.ts"
+import * as System from "../System.ts"
+import * as Effectify from "../_Effectify.ts"
 
 const handleBadArgument = (method: string) => (cause: unknown) =>
-  new PlatformError.BadArgument({
+  new System.SystemError({
+    reason: "BadArgument",
     module: "FileSystem",
     method,
     cause,
@@ -324,7 +325,7 @@ const makeFile = (() => {
       )
     }
 
-    private writeAllChunk(buffer: Uint8Array): Effect.Effect<void, PlatformError.PlatformError> {
+    private writeAllChunk(buffer: Uint8Array): Effect.Effect<void, System.SystemError> {
       return Effect.flatMap(
         Effect.suspend(() =>
           nodeWriteAll(
@@ -338,7 +339,7 @@ const makeFile = (() => {
         (bytesWritten) => {
           if (bytesWritten === 0) {
             return Effect.fail(
-              new PlatformError.SystemError({
+              new System.SystemError({
                 module: "FileSystem",
                 method: "writeAll",
                 reason: "WriteZero",
@@ -398,7 +399,7 @@ const readDirectory = (path: string, options?: FileSystem.ReadDirectoryOptions)
   })
 
 const readFile = (path: string) =>
-  Effect.async<Uint8Array, PlatformError.PlatformError>((resume, signal) => {
+  Effect.async<Uint8Array, System.SystemError>((resume, signal) => {
     try {
       NFS.readFile(path, { signal }, (err, data) => {
         if (err) {
@@ -508,7 +509,7 @@ const utimes = (() => {
 })()
 
 const watchNode = (path: string, options?: FileSystem.WatchOptions) =>
-  Stream.asyncScoped<FileSystem.WatchEvent, PlatformError.PlatformError>((emit) =>
+  Stream.asyncScoped<FileSystem.WatchEvent, System.SystemError>((emit) =>
     Effect.acquireRelease(
       Effect.sync(() => {
         const watcher = NFS.watch(path, { recursive: options?.recursive }, (event, path) => {
@@ -534,7 +535,7 @@ const watchNode = (path: string, options?: FileSystem.WatchOptions) =>
         })
         watcher.on("error", (error) => {
           emit.fail(
-            new PlatformError.SystemError({
+            new System.SystemError({
               module: "FileSystem",
               reason: "Unknown",
               method: "watch",
@@ -568,7 +569,7 @@ const watch = (
   )
 
 const writeFile = (path: string, data: Uint8Array, options?: FileSystem.WriteFileOptions) =>
-  Effect.async<void, PlatformError.PlatformError>((resume, signal) => {
+  Effect.async<void, System.SystemError>((resume, signal) => {
     try {
       NFS.writeFile(
         path,
@@ -624,14 +625,14 @@ const make = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend)
 
 export const layer = Layer.effect(FileSystem.FileSystem, make)
 
-export { PlatformError as Error }
+export { System as Error }
 
-export function handleErrnoException(module: PlatformError.SystemError["module"], method: string) {
+export function handleErrnoException(module: System.SystemError["module"], method: string) {
   return function (
     err: NodeJS.ErrnoException,
     [path]: [path: NFS.PathLike | number, ...args: Array<any>],
-  ): PlatformError.PlatformError {
-    let reason: PlatformError.SystemErrorReason = "Unknown"
+  ): System.SystemError {
+    let reason: System.SystemErrorReason = "Unknown"
 
     switch (err.code) {
       case "ENOENT":
@@ -663,7 +664,7 @@ export function handleErrnoException(module: PlatformError.SystemError["module"]
         break
     }
 
-    return new PlatformError.SystemError({
+    return new System.SystemError({
       reason,
       module,
       method,

package/src/sql/SqlCache.ts

@@ -0,0 +1,63 @@
+import * as Cache from "effect/Cache"
+import * as Context from "effect/Context"
+import type * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type * as SqlClient from "./SqlClient.ts"
+
+type SqlCacheInstance = Cache.Cache<string, ReadonlyArray<any>>
+
+export class SqlCache extends Context.Tag("effect-start/SqlCache")<SqlCache, SqlCacheInstance>() {}
+
+export function layer(cache: SqlCacheInstance): Layer.Layer<SqlCache>
+export function layer(options: {
+  readonly capacity: number
+  readonly timeToLive: Duration.DurationInput
+}): Layer.Layer<SqlCache>
+export function layer(
+  cacheOrOptions:
+    | SqlCacheInstance
+    | { readonly capacity: number; readonly timeToLive: Duration.DurationInput },
+): Layer.Layer<SqlCache> {
+  if (Cache.CacheTypeId in cacheOrOptions) {
+    return Layer.succeed(SqlCache, cacheOrOptions as SqlCacheInstance)
+  }
+  const options = cacheOrOptions as {
+    readonly capacity: number
+    readonly timeToLive: Duration.DurationInput
+  }
+  return Layer.effect(
+    SqlCache,
+    Cache.make<string, ReadonlyArray<any>>({
+      capacity: options.capacity,
+      timeToLive: options.timeToLive,
+      lookup: (key) => Effect.die(`cache miss without populate for key: ${key}`),
+    }),
+  )
+}
+
+export function withCache(
+  cache: SqlCacheInstance,
+): <A extends object>(
+  self: SqlClient.SqlEffect<A>,
+) => Effect.Effect<ReadonlyArray<A>, SqlClient.SqlError>
+export function withCache(): <A extends object>(
+  self: SqlClient.SqlEffect<A>,
+) => Effect.Effect<ReadonlyArray<A>, SqlClient.SqlError, SqlCache>
+export function withCache(cache?: SqlCacheInstance) {
+  return <A extends object>(self: SqlClient.SqlEffect<A>) => {
+    const key = JSON.stringify({ sql: self.sql, parameters: self.parameters })
+    if (cache) {
+      return Effect.flatMap(cache.getOption(key), (option) => {
+        if (option._tag === "Some") return Effect.succeed(option.value as ReadonlyArray<A>)
+        return Effect.tap(self, (result) => cache.set(key, result))
+      })
+    }
+    return Effect.flatMap(SqlCache, (c) =>
+      Effect.flatMap(c.getOption(key), (option) => {
+        if (option._tag === "Some") return Effect.succeed(option.value as ReadonlyArray<A>)
+        return Effect.tap(self, (result) => c.set(key, result))
+      }),
+    )
+  }
+}