effect-start 0.26.0 → 0.27.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "effect-start",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "license": "MIT",
   "files": [
     "src/",
     "!src/**/*.test.ts",
     "!src/**/*.test.tsx",
+    "!src/tower",
     "dist/",
     "README.md",
     "package.json"
@@ -16,7 +17,8 @@
     "./bun": "./src/bun/index.ts",
     "./client": "./src/client/index.ts",
     "./testing": "./src/testing/index.ts",
-    "./console": "./src/console/index.ts",
+    "./tower": "./src/tower/index.ts",
+    "./sql": "./src/sql/index.ts",
     "./sql/*": "./src/sql/*/index.ts",
     "./x/*": "./src/x/*/index.ts",
     "./x/tailwind/plugin": "./src/x/tailwind/plugin.ts",

package/src/Entity.ts

@@ -1,6 +1,6 @@
+import * as Effectable from "effect/Effectable"
 import * as Effect from "effect/Effect"
 import * as ParseResult from "effect/ParseResult"
-import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
@@ -24,7 +24,7 @@ export type Headers = {
   [header: string]: string | null | undefined
 }
 
-export interface Entity<T = unknown, E = never> extends Pipeable.Pipeable {
+export interface Entity<T = unknown, E = never> extends Effect.Effect<Entity<T, E>, E> {
   readonly [TypeId]: TypeId
   readonly body: T
   readonly headers: Headers
@@ -57,7 +57,7 @@ export interface Entity<T = unknown, E = never> extends Pipeable.Pipeable {
     : Stream.Stream<Uint8Array, ParseResult.ParseError | E>
 }
 
-export interface Proto extends Pipeable.Pipeable {
+export interface Proto extends Effect.Effect<Entity, never> {
   readonly [TypeId]: TypeId
 }
 
@@ -218,11 +218,11 @@ function getStream(self: Entity<unknown, unknown>): Stream.Stream<unknown, unkno
   return Stream.fromEffect(getBytes(self))
 }
 
-const Proto: Proto = Object.defineProperties(Object.create(null), {
+const Proto: Proto = Object.defineProperties(Object.create(Effectable.CommitPrototype), {
   [TypeId]: { value: TypeId },
-  pipe: {
+  commit: {
     value: function (this: Entity) {
-      return Pipeable.pipeArguments(this, arguments)
+      return resolve(this)
     },
   },
   text: {

package/src/FileRouterCodegen.ts

@@ -166,14 +166,14 @@ export function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string |
   }
 
   const routeEntries = entries
-    .map(({ path, loaders }) => {
-      const loadersCode = loaders.join(",\n    ")
-      return `  "${path}": [\n    ${loadersCode},\n  ]`
+    .map((v) => {
+      const loadersCode = v.loaders.join(",\n    ")
+      return `  "${v.path}": [\n    ${loadersCode},\n  ]`
     })
     .join(",\n")
 
   return `/**
- * Auto-generated by effect-start.
+ * Auto-generated by effect-start on startup and changes. Do not edit manually.
  */
 
 export default {

package/src/FileSystem.ts

@@ -344,14 +344,10 @@ export const make = (
 
 const fileStream = (
   file: File,
-  {
-    bufferSize = 16,
-    bytesToRead: bytesToRead_,
-    chunkSize: chunkSize_ = Size(64 * 1024),
-  }: StreamOptions = {},
+  options: StreamOptions = {},
 ) => {
-  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
-  const chunkSize = Size(chunkSize_)
+  const bytesToRead = options.bytesToRead !== undefined ? Size(options.bytesToRead) : undefined
+  const chunkSize = Size(options.chunkSize ?? 64 * 1024)
 
   function loop(
     totalBytesRead: bigint,
@@ -385,6 +381,6 @@ const fileStream = (
   }
 
   return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), {
-    capacity: bufferSize,
+    capacity: options.bufferSize ?? 16,
   })
 }

package/src/RouteHook.ts

@@ -34,7 +34,7 @@ export function filter<
 
           const mergedContext = filterResult ? { ...context, ...filterResult.context } : context
 
-          return yield* Entity.resolve(next(mergedContext as Partial<BOut>))
+          return yield* next(mergedContext as Partial<BOut>)
         }),
     )
 

package/src/RouteSse.ts

@@ -13,7 +13,7 @@ const HEARTBEAT = ": <3\n\n"
 
 export interface SseEvent {
   data?: string | undefined
-  event?: string
+  type?: string
   retry?: number
 }
 
@@ -35,8 +35,8 @@ function formatSseEvent(event: SseEventInput): string {
 
   const e = event as SseEvent
   let result = ""
-  if (e.event) {
-    result += `event: ${e.event}\n`
+  if (e.type) {
+    result += `event: ${e.type}\n`
   }
   if (typeof e.data === "string") {
     for (const line of e.data.split("\n")) {

package/src/SqlIntrospect.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import * as Sql from "./sql/Sql.ts"
+import * as Sql from "./sql/SqlClient.ts"
 
 export interface Column {
   readonly tableSchema: string
@@ -496,7 +496,7 @@ export interface DatabaseReader {
 const escapeIdentifier = (id: string): string => `"${id.replace(/"/g, '""')}"`
 
 const concatSql = (
-  sql: Sql.SqlQuery,
+  sql: Sql.Connection,
   fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }>,
 ): Effect.Effect<ReadonlyArray<unknown>, Sql.SqlError> => {
   const strings: Array<string> = []

package/src/Start.ts

@@ -2,8 +2,12 @@ import type * as FileSystem from "./FileSystem.ts"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
 import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
+import * as SynchronizedRef from "effect/SynchronizedRef"
 import type * as ChildProcess from "./ChildProcess.ts"
 import * as BunRuntime from "./bun/BunRuntime.ts"
 import * as BunServer from "./bun/BunServer.ts"
@@ -44,8 +48,10 @@ export function layer<
  * @since 1.0.0
  * @category constructors
  */
-export function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
-  ...layers: Layers
+export function pack<
+  const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>],
+>(
+  ...layers: Layers & OrderedPack<NoInfer<Layers>, NoInfer<Layers>>
 ): Layer.Layer<
   { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number],
   { [K in keyof Layers]: Layer.Layer.Error<Layers[K]> }[number],
@@ -64,6 +70,100 @@ export function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<La
   return result as AnyLayer
 }
 
+type Unsatisfied<Unmet, Success> =
+  Unmet extends Success ? Unmet : never
+
+type OrderedPack<
+  Layers extends readonly Layer.Layer.Any[],
+  All extends readonly Layer.Layer.Any[],
+> = Layers extends readonly [
+  infer Head extends Layer.Layer.Any,
+  ...infer Tail extends Layer.Layer.Any[],
+]
+  ? [
+    [
+      Unsatisfied<
+        Exclude<Layer.Layer.Context<Head>, { [K in keyof Tail]: Layer.Layer.Success<Tail[K]> }[number]>,
+        { [K in keyof All]: Layer.Layer.Success<All[K]> }[number]
+      >,
+    ] extends [never]
+    ? Head
+    : never,
+    ...OrderedPack<Tail, All>,
+  ]
+  : []
+
+/**
+ * Like `pack`, but accepts layers in any order.
+ *
+ * ```ts
+ * // These all produce the same result:
+ * Start.build(LoggerLive, DatabaseLive, UserRepoLive)
+ * Start.build(UserRepoLive, DatabaseLive, LoggerLive)
+ * ```
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function build<
+  const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>],
+>(
+  ...layers: Layers
+): Layer.Layer<
+  { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number],
+  { [K in keyof Layers]: Layer.Layer.Error<Layers[K]> }[number],
+  Exclude<
+    { [K in keyof Layers]: Layer.Layer.Context<Layers[K]> }[number],
+    { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number]
+  >
+> {
+  type AnyLayer = Layer.Layer<any, any, any>
+  const layerArray = layers as unknown as ReadonlyArray<AnyLayer>
+
+  return Layer.scopedContext(
+    Effect.gen(function* () {
+      const scope = yield* Effect.scope
+      const memoMap = yield* Layer.makeMemoMap
+      const memoMapRef = (memoMap as any).ref as SynchronizedRef.SynchronizedRef<Map<AnyLayer, any>>
+      let ctx = yield* Effect.context<any>()
+      const pending = new Set<AnyLayer>(layerArray)
+
+      for (let pass = 0; pass < layerArray.length && pending.size > 0; pass++) {
+        for (const layer of [...pending]) {
+          const childScope = yield* Scope.fork(scope, ExecutionStrategy.sequential)
+          const exit = yield* layer.pipe(
+            Layer.buildWithMemoMap(memoMap, childScope),
+            Effect.provide(ctx),
+            Effect.exit,
+          )
+          if (Exit.isSuccess(exit)) {
+            ctx = Context.merge(ctx, exit.value)
+            pending.delete(layer)
+          } else {
+            yield* Scope.close(childScope, exit)
+            yield* SynchronizedRef.update(memoMapRef, (map) => {
+              map.delete(layer)
+              return map
+            })
+          }
+        }
+      }
+
+      for (const layer of pending) {
+        const childScope = yield* Scope.fork(scope, ExecutionStrategy.sequential)
+        const built = yield* layer.pipe(
+          Layer.buildWithMemoMap(memoMap, childScope),
+          Effect.provide(ctx),
+        )
+        ctx = Context.merge(ctx, built)
+      }
+
+      return ctx
+    }),
+    // TODO: not sure how to properly type it yet
+  ) as any
+}
+
 export type PlatformServices =
   | BunServer.BunServer
   | FileSystem.FileSystem

package/src/Values.ts

@@ -73,9 +73,20 @@ export const firstValue = <T>(record: Record<string, T>): T | undefined => {
   return undefined
 }
 
+export const isTemplateStringsArray = (value: unknown): value is TemplateStringsArray =>
+  Array.isArray(value) && "raw" in value
+
 export const concatBytes = (a: Uint8Array, b: Uint8Array): Uint8Array => {
   const result = new Uint8Array(a.byteLength + b.byteLength)
   result.set(a)
   result.set(b, a.byteLength)
   return result
 }
+
+export const compact = (record: Record<string, unknown | undefined>): Record<string, unknown> => {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(record)) {
+    if (value !== undefined) out[key] = value
+  }
+  return out
+}

package/src/bun/BunRoute.ts

@@ -113,7 +113,7 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
             }),
         })
 
-        const childEntity = yield* Entity.resolve(next(context))
+        const childEntity = yield* next(context)
         const children = childEntity?.body ?? childEntity
 
         let childrenHtml = ""

package/src/bun/BunRuntime.ts

@@ -7,19 +7,19 @@ const mainFiber = GlobalValue.globalValue(Symbol.for("effect-start/BunRuntime/ex
   MutableRef.make<Fiber.RuntimeFiber<unknown, unknown> | undefined>(undefined),
 )
 
-export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown }) => {
+export const runMain = PlatformRuntime.makeRunMain((options) => {
   const prevFiber = MutableRef.get(mainFiber)
 
-  MutableRef.set(mainFiber, fiber)
+  MutableRef.set(mainFiber, options.fiber)
 
   let receivedSignal = false
 
-  fiber.addObserver((exit) => {
+  options.fiber.addObserver((exit) => {
     if (!receivedSignal) {
       process.removeListener("SIGINT", onSigint)
       process.removeListener("SIGTERM", onSigint)
     }
-    teardown(exit, (code) => {
+    options.teardown(exit, (code) => {
       if (receivedSignal || code !== 0) {
         process.exit(code)
       }
@@ -30,7 +30,7 @@ export const runMain = PlatformRuntime.makeRunMain(({ fiber, teardown }) => {
     receivedSignal = true
     process.removeListener("SIGINT", onSigint)
     process.removeListener("SIGTERM", onSigint)
-    fiber.unsafeInterruptAsFork(fiber.id())
+    options.fiber.unsafeInterruptAsFork(options.fiber.id())
   }
 
   process.on("SIGINT", onSigint)

package/src/hyper/HyperHtml.ts

@@ -53,6 +53,9 @@ let map = {
 
 const RAW_TEXT_TAGS = ["script", "style"]
 
+// Prevents closing html tags in embedded css/js source
+const escapeRawText = (text: string) => text.replaceAll("</", "<\\/")
+
 export function renderToString(
   node: JSX.Children,
   hooks?: { onNode?: (node: HyperNode.HyperNode) => void },
@@ -113,8 +116,7 @@ export function renderToString(
       for (const key in props) {
         if (
           key !== "children" &&
-          key !== "innerHTML" && // Solid-specific
-          key !== "dangerouslySetInnerHTML" && // React-specific
+          key !== "dangerouslySetInnerHTML" &&
           props[key] !== false &&
           props[key] != null
         ) {
@@ -140,17 +142,19 @@ export function renderToString(
       if (!EMPTY_TAGS.includes(type)) {
         stack.push(`</${type}>`)
 
-        const html = props.dangerouslySetInnerHTML?.__html ?? props.innerHTML
+        const isRawText = RAW_TEXT_TAGS.includes(type)
+        const html = props.dangerouslySetInnerHTML?.__html
 
         if (html) {
-          result += html
+          result += isRawText ? escapeRawText(html) : html
         } else {
           const children = props.children
 
           if (type === "script" && typeof children === "function") {
-            result += `(${children.toString()})(window)`
-          } else if (RAW_TEXT_TAGS.includes(type) && children != null) {
-            result += Array.isArray(children) ? children.join("") : children
+            result += escapeRawText(`(${children.toString()})(window)`)
+          } else if (isRawText && children != null) {
+            const raw = Array.isArray(children) ? children.join("") : String(children)
+            result += escapeRawText(raw)
           } else if (Array.isArray(children)) {
             for (let i = children.length - 1; i >= 0; i--) {
               stack.push(children[i])

package/src/hyper/jsx.d.ts

@@ -536,7 +536,7 @@ export namespace JSX {
     // [key: ClassKeys]: boolean;
 
     // properties
-    innerHTML?: string
+    dangerouslySetInnerHTML?: { __html: string }
     textContent?: string | number
 
     // attributes

package/src/lint/plugin.js

@@ -55,15 +55,41 @@ export default {
 
             const typePrefix = node.importKind === "type" ? "type " : ""
 
+            const sourceCode = context.sourceCode || context.getSourceCode()
+
             context.report({
               node,
               messageId: "preferNamespace",
               data: { source, baseName, typePrefix },
               fix(fixer) {
-                return fixer.replaceText(
-                  node,
-                  `import ${typePrefix}* as ${baseName} from "${source}"`,
-                )
+                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
               },
             })
           },
@@ -182,6 +208,150 @@ export default {
       },
     },
 
+    "no-destructured-params": {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description: "Disallow destructuring objects in function parameters",
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+          noDestructuredParam:
+            "Avoid destructuring objects in function parameters. Use a single parameter and access properties on it instead.",
+        },
+      },
+      create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode()
+
+        function findUnusedName(scope, base) {
+          const names = new Set()
+          let current = scope
+          while (current) {
+            for (const v of current.variables) names.add(v.name)
+            current = current.upper
+          }
+          if (!names.has(base)) return base
+          for (let i = 2; ; i++) {
+            const candidate = base + i
+            if (!names.has(candidate)) return candidate
+          }
+        }
+
+        function isDefinition(node) {
+          if (node.type === "FunctionDeclaration") return true
+          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
+          return false
+        }
+
+        function checkParams(node) {
+          for (const param of node.params) {
+            const pattern =
+              param.type === "AssignmentPattern" ? param.left : param
+            if (pattern.type !== "ObjectPattern") continue
+
+            const baseName = isDefinition(node) ? "options" : "v"
+            const outerScope = sourceCode.getScope(node).upper || sourceCode.getScope(node)
+            const name = findUnusedName(outerScope, baseName)
+
+            const hasPropertyDefaults = pattern.properties.some(
+              (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,
+                        ),
+                      )
+                    }
+                  }
+                }
+
+                return fixes
+              },
+            })
+          }
+        }
+
+        return {
+          FunctionDeclaration: checkParams,
+          FunctionExpression: checkParams,
+          ArrowFunctionExpression: checkParams,
+        }
+      },
+    },
+
     "test-assertion-newline": {
       meta: {
         type: "layout",