effect-start 0.27.0 → 0.28.0

package/src/Unique.ts

@@ -4,6 +4,56 @@ export const ALPHABET_BASE64_URL =
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
 export const ALPHABET_HEX = "0123456789abcdef"
 
+interface SnowflakeState {
+  timestampMs: bigint
+  sequence: bigint
+}
+
+interface Snowflake {
+  (): bigint
+  readonly state: SnowflakeState
+  readonly timestamp: (id: bigint) => bigint
+}
+
+function buildSnowflake(): {
+  (): bigint
+  readonly state: SnowflakeState
+  readonly timestamp: (id: bigint) => bigint
+} {
+  const timestampBits = 48n
+  const seqBits = 16n
+  const seqMax = (1n << seqBits) - 1n
+  const timestampMask = (1n << timestampBits) - 1n
+
+  const fn = Object.assign(
+    () => {
+      const nowMs = BigInt(Date.now())
+      const timestampMs = nowMs > fn.state.timestampMs ? nowMs : fn.state.timestampMs
+
+      if (timestampMs > fn.state.timestampMs) {
+        fn.state.timestampMs = timestampMs
+        fn.state.sequence = 0n
+      } else {
+        fn.state.sequence += 1n
+        if (fn.state.sequence > seqMax) {
+          fn.state.timestampMs += 1n
+          fn.state.sequence = 0n
+        }
+      }
+
+      return ((fn.state.timestampMs & timestampMask) << seqBits) | fn.state.sequence
+    },
+    {
+      state: {
+        timestampMs: 0n,
+        sequence: -1n,
+      },
+      timestamp: (id: bigint): bigint => id >> seqBits,
+    },
+  )
+  return fn
+}
+
 /**
  * Generate a random string for ids, session tokens, and API keys.
  * It uses human-friendly crockford base32 encoding (5 bit of entropy per char)
@@ -169,6 +219,15 @@ function toSafeTime(time: number): number {
   return Math.max(0, Math.trunc(time))
 }
 
+/**
+ * Monotonic Snowflake variant:
+ * - 48-bit unix timestamp (ms)
+ * - 16-bit sequence
+ * - sequence resets on timestamp increment
+ * - over-capacity sequence carries into next millisecond
+ */
+export const snowflake = buildSnowflake()
+
 /**
  * Generate a nanoid-style random string.
  *

package/src/bun/BunChildProcessSpawner.ts

@@ -6,21 +6,14 @@ import type * as BunTypes from "bun"
 import * as ChildProcess from "../ChildProcess.ts"
 import * as PlatformError from "../PlatformError.ts"
 
-const toCmd = (command: ChildProcess.Command): ReadonlyArray<string> => [
-  command.command,
-  ...command.args,
-]
-
 export const layer: Layer.Layer<ChildProcess.ChildProcessSpawner> = Layer.succeed(
   ChildProcess.ChildProcessSpawner,
   {
     spawn: (command) =>
       Effect.gen(function* () {
-        const cmd = toCmd(command)
-
         const proc = yield* Effect.try({
           try: () =>
-            Bun.spawn(cmd as Array<string>, {
+            Bun.spawn([...command.cmd], {
               cwd: command.cwd,
               env: command.env,
               stdin: command.stdin ?? "ignore",

package/src/bun/BunRoute.ts

@@ -156,6 +156,7 @@ type BunServerFetchHandler = (
 
 type BunServerRouteHandler =
   | Bun.HTMLBundle
+  | Bun.BunFile
   | BunServerFetchHandler
   | Partial<Record<Bun.Serve.HTTPMethod, BunServerFetchHandler>>
 

package/src/bun/BunRuntime.ts

@@ -1,16 +1,10 @@
-import type * as Fiber from "effect/Fiber"
-import * as GlobalValue from "effect/GlobalValue"
 import * as MutableRef from "effect/MutableRef"
 import * as PlatformRuntime from "../PlatformRuntime.ts"
 
-const mainFiber = GlobalValue.globalValue(Symbol.for("effect-start/BunRuntime/existingFiber"), () =>
-  MutableRef.make<Fiber.RuntimeFiber<unknown, unknown> | undefined>(undefined),
-)
-
 export const runMain = PlatformRuntime.makeRunMain((options) => {
-  const prevFiber = MutableRef.get(mainFiber)
+  const prevFiber = MutableRef.get(PlatformRuntime.mainFiber)
 
-  MutableRef.set(mainFiber, options.fiber)
+  MutableRef.set(PlatformRuntime.mainFiber, options.fiber)
 
   let receivedSignal = false
 

package/src/bun/BunServer.ts

@@ -12,7 +12,7 @@ import type * as Scope from "effect/Scope"
 import * as NOs from "node:os"
 import * as NPath from "node:path"
 import * as PathPattern from "../PathPattern.ts"
-import * as PlataformRuntime from "../PlatformRuntime.ts"
+import * as PlatformRuntime from "../PlatformRuntime.ts"
 import * as Route from "../Route.ts"
 import * as RouteHttp from "../RouteHttp.ts"
 import * as StartApp from "../StartApp.ts"
@@ -60,7 +60,7 @@ export const make = (
   Effect.gen(function* () {
     const port = yield* Config.number("PORT").pipe(
       Effect.catchTag("ConfigError", () => {
-        return PlataformRuntime.isAgentHarness()
+        return PlatformRuntime.isAgentHarness()
           ? Effect.succeed(0) // random port
           : Effect.succeed(3000)
       }),
@@ -228,11 +228,14 @@ function walkBunRoutes(runtime: Runtime.Runtime<BunServer>, tree: RouteTree.Rout
     const pathGroups = new Map<string, Array<RouteMount.MountedRoute>>()
     const toWebHandler = RouteHttp.toWebHandlerRuntime(runtime)
 
+    let hasPrebuiltBundles = false
+
     for (const route of RouteTree.walk(tree)) {
       const bunDescriptors = BunRoute.descriptors(route)
       if (bunDescriptors) {
         const htmlBundle = yield* Effect.promise(bunDescriptors.bunLoad)
         if (htmlBundle.files) {
+          hasPrebuiltBundles = true
           registerPrebuiltBundle(bunDescriptors.bunPrefix, htmlBundle, bunRoutes)
         } else {
           bunRoutes[`${bunDescriptors.bunPrefix}/*`] = htmlBundle
@@ -252,6 +255,15 @@ function walkBunRoutes(runtime: Runtime.Runtime<BunServer>, tree: RouteTree.Rout
       }
     }
 
+    if (hasPrebuiltBundles) {
+      const mainDir = NPath.dirname(Bun.main)
+      for (const output of discoverStaticOutputs(mainDir)) {
+        const routePath = `/${NPath.basename(output.path)}`
+        if (routePath in bunRoutes) continue
+        bunRoutes[routePath] = Bun.file(output.path)
+      }
+    }
+
     return bunRoutes
   })
 }
@@ -274,6 +286,38 @@ function registerPrebuiltBundle(prefix: string, bundle: any, bunRoutes: BunRoute
   }
 }
 
+type StaticOutput = Pick<Bun.BuildArtifact, "path" | "loader" | "kind">
+
+function discoverStaticOutputs(dir: string): Array<StaticOutput> {
+  const loaderByExt: Record<string, Bun.Loader> = {
+    ".js": "js",
+    ".mjs": "js",
+    ".cjs": "js",
+    ".jsx": "jsx",
+    ".tsx": "tsx",
+    ".ts": "ts",
+    ".css": "css",
+    ".html": "html",
+    ".json": "json",
+    ".jsonc": "jsonc",
+    ".toml": "toml",
+    ".yaml": "yaml",
+    ".wasm": "wasm",
+    ".txt": "text",
+  }
+
+  const outputs: Array<StaticOutput> = []
+  for (const entry of new Bun.Glob("*").scanSync({ cwd: dir, onlyFiles: true })) {
+    const ext = NPath.extname(entry).toLowerCase()
+    outputs.push({
+      path: NPath.resolve(dir, entry),
+      loader: loaderByExt[ext] ?? "file",
+      kind: "asset",
+    })
+  }
+  return outputs
+}
+
 function rewriteRelativeAssetPaths(html: string | Promise<string>): Promise<string> {
   const rewriter = new HTMLRewriter()
     .on("link[href]", {
@@ -292,6 +336,14 @@ function rewriteRelativeAssetPaths(html: string | Promise<string>): Promise<stri
         }
       },
     })
+    .on("img[src]", {
+      element(el) {
+        const src = el.getAttribute("src")
+        if (src && isRelativePath(src)) {
+          el.setAttribute("src", "/" + assetBasename(src))
+        }
+      },
+    })
 
   return Promise.resolve(html).then((h) => rewriter.transform(new Response(h)).text())
 }

package/src/datastar/watchers/patchElements.ts

@@ -403,7 +403,6 @@ const removeNode = (node: Node): void => {
 }
 
 const moveBefore: (parentNode: Node, node: Node, after: Node | null) => void =
-  // @ts-expect-error
   removeNode.call.bind(ctxPantry.moveBefore ?? ctxPantry.insertBefore)
 
 const aliasedPreserveAttr = aliasify("preserve-attr")

package/src/lint/plugin.js

@@ -63,10 +63,7 @@ export default {
               data: { source, baseName, typePrefix },
               fix(fixer) {
                 const fixes = [
-                  fixer.replaceText(
-                    node,
-                    `import ${typePrefix}* as ${baseName} from "${source}"`,
-                  ),
+                  fixer.replaceText(node, `import ${typePrefix}* as ${baseName} from "${source}"`),
                 ]
 
                 for (const specifier of node.specifiers) {
@@ -243,18 +240,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 +256,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)
-                  }
-                }
+              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),
+                    )
 
-                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,
-                        ),
-                      )
+                    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 +339,80 @@ export default {
       },
     },
 
+    "namespace-import-mismatch": {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description:
+            "Warn when a namespace import alias doesn't match the basename of the module path",
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+          mismatch:
+            'Namespace import alias "{{alias}}" does not match module basename "{{baseName}}"',
+        },
+      },
+      create(context) {
+        const importNames = new Set()
+
+        return {
+          ImportDeclaration(node) {
+            for (const spec of node.specifiers) {
+              importNames.add(spec.local.name)
+            }
+
+            const source = node.source.value
+            if (typeof source !== "string") return
+
+            if (
+              node.specifiers.length !== 1 ||
+              node.specifiers[0].type !== "ImportNamespaceSpecifier"
+            ) {
+              return
+            }
+
+            if (!isLocalImport(source)) return
+
+            const baseName = getBaseName(source)
+            if (!baseName) return
+            if (!isCapitalized(baseName)) return
+
+            const alias = node.specifiers[0].local.name
+            if (alias === baseName) return
+
+            const hasCollision = importNames.has(baseName) && alias !== baseName
+            const sourceCode = context.sourceCode || context.getSourceCode()
+
+            context.report({
+              node,
+              messageId: "mismatch",
+              data: { alias, baseName },
+              fix: hasCollision
+                ? undefined
+                : (fixer) => {
+                    const fixes = [
+                      fixer.replaceText(
+                        node,
+                        `import ${node.importKind === "type" ? "type " : ""}* as ${baseName} from "${source}"`,
+                      ),
+                    ]
+
+                    for (const variable of sourceCode.getDeclaredVariables(node.specifiers[0])) {
+                      for (const ref of variable.references) {
+                        if (ref.identifier.range[0] === node.specifiers[0].local.range[0]) continue
+                        fixes.push(fixer.replaceTextRange(ref.identifier.range, baseName))
+                      }
+                    }
+
+                    return fixes
+                  },
+            })
+          },
+        }
+      },
+    },
+
     "test-assertion-newline": {
       meta: {
         type: "layout",
@@ -552,6 +613,10 @@ function getBaseName(source) {
   return last
 }
 
+function isLocalImport(source) {
+  return source.startsWith(".") || source.startsWith("/")
+}
+
 function isCapitalized(name) {
   return name.length > 0 && name[0] >= "A" && name[0] <= "Z"
 }

package/src/sql/SqlCache.ts

@@ -0,0 +1,50 @@
+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(options: {
+  readonly capacity: number
+  readonly timeToLive: Duration.DurationInput
+}): Layer.Layer<SqlCache> {
+  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))
+      }),
+    )
+  }
+}