effect-start 0.22.0 → 0.23.0

package/src/hyper/Hyper.ts

@@ -1,8 +1,6 @@
 import * as Context from "effect/Context"
 import * as Fiber from "effect/Fiber"
-import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
-import type { HyperHooks } from "../x/datastar/index.ts"
 import type { JSX } from "./jsx.d.ts"
 
 type Elements = JSX.IntrinsicElements
@@ -11,20 +9,7 @@ type Children = JSX.Children
 
 export type { Children, Elements, JSX }
 
-export class Hyper extends Context.Tag("Hyper")<
-  Hyper,
-  {
-    hooks: typeof HyperHooks | undefined
-  }
->() {}
-
-export function layer(opts: { hooks: typeof HyperHooks }) {
-  return Layer.sync(Hyper, () => {
-    return {
-      hooks: opts.hooks,
-    }
-  })
-}
+export class Hyper extends Context.Tag("Hyper")<Hyper, {}>() {}
 
 const NoChildren: ReadonlyArray<never> = Object.freeze([])
 

package/src/hyper/HyperHtml.ts

@@ -41,14 +41,14 @@ const EMPTY_TAGS = [
   "wbr",
 ]
 
-// escape an attribute
 let esc = (str: any) => String(str).replace(/[&<>"']/g, (s) => `&${map[s]};`)
+let escSQ = (str: any) => String(str).replace(/[&<>']/g, (s) => `&${map[s]};`)
 let map = {
   "&": "amp",
   "<": "lt",
   ">": "gt",
   '"': "quot",
-  "'": "apos",
+  "'": "#39",
 }
 
 const RAW_TEXT_TAGS = ["script", "style"]
@@ -124,8 +124,10 @@ export function renderToString(
             const resolvedKey = key === "className" ? "class" : key
             const value = props[key]
 
-            if (key.startsWith("data-") && typeof value === "object") {
-              result += ` ${esc(resolvedKey)}="${esc(JSON.stringify(value))}"`
+            if (key.startsWith("data-") && typeof value === "function") {
+              result += ` ${esc(resolvedKey)}="${esc(value.toString())}"`
+            } else if (key.startsWith("data-") && typeof value === "object") {
+              result += ` ${esc(resolvedKey)}='${escSQ(JSON.stringify(value))}'`
             } else {
               result += ` ${esc(resolvedKey)}="${esc(value)}"`
             }

package/src/hyper/HyperRoute.ts

@@ -2,6 +2,7 @@ import * as Effect from "effect/Effect"
 import * as Entity from "../Entity.ts"
 import * as Route from "../Route.ts"
 import type * as RouteBody from "../RouteBody.ts"
+import type * as Values from "../Values.ts"
 import * as HyperHtml from "./HyperHtml.ts"
 import type { JSX } from "./jsx.d.ts"
 
@@ -20,7 +21,7 @@ function renderValue(
 
 function normalizeToEffect<B, A, E, R>(
   handler: RouteBody.HandlerInput<B, A, E, R>,
-  context: B,
+  context: Values.Simplify<B>,
   next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<A>,
 ): Effect.Effect<A | Entity.Entity<A>, E, R> {
   if (Effect.isEffect(handler)) {

package/src/hyper/html.ts

@@ -0,0 +1,47 @@
+const HtmlStringSymbol = Symbol.for("HtmlString")
+
+export interface HtmlString {
+  readonly [HtmlStringSymbol]: true
+  readonly value: string
+}
+
+const makeHtmlString = (value: string): HtmlString => ({
+  [HtmlStringSymbol]: true,
+  value,
+})
+
+const isHtmlString = (value: unknown): value is HtmlString =>
+  typeof value === "object" && value !== null && HtmlStringSymbol in value
+
+export type HtmlValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | undefined
+  | HtmlString
+  | Function
+  | Record<string, unknown>
+  | ReadonlyArray<HtmlValue>
+
+const resolveValue = (value: HtmlValue): string => {
+  if (value === null || value === undefined || value === false || value === true) return ""
+  if (isHtmlString(value)) return value.value
+  if (Array.isArray(value)) return (value as Array<HtmlValue>).map(resolveValue).join("")
+  if (typeof value === "function") return value.toString()
+  if (typeof value === "object") return JSON.stringify(value)
+  if (typeof value === "string") return value
+  return String(value)
+}
+
+export const html = (strings: TemplateStringsArray, ...values: Array<HtmlValue>): HtmlString => {
+  let result = strings[0]
+  for (let i = 0; i < values.length; i++) {
+    result += resolveValue(values[i])
+    result += strings[i + 1]
+  }
+  return makeHtmlString(result)
+}
+
+html.raw = (value: string): HtmlString => makeHtmlString(value)

package/src/hyper/index.ts

@@ -1,4 +1,6 @@
 export * as Hyper from "./Hyper.ts"
+export { html } from "./html.ts"
+export type { HtmlString, HtmlValue } from "./html.ts"
 export * as HyperHtml from "./HyperHtml.ts"
 export * as HyperNode from "./HyperNode.ts"
 export * as HyperRoute from "./HyperRoute.ts"

package/src/hyper/jsx.d.ts

@@ -1,5 +1,5 @@
-import type * as HyperNode from "./hyper/HyperNode.ts"
-import type { DatastarAttributes } from "./x/datastar/jsx-datastar.ts"
+import type * as HyperNode from "./HyperNode.ts"
+import type { DatastarAttributes } from "../datastar/jsx.d.ts"
 
 /**
  * Based on JSX types for Surplus, Inferno, and dom-expressions.
@@ -3499,7 +3499,9 @@ export namespace JSX {
      * @url https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script
      * @url https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement
      */
-    script: ScriptHTMLAttributes<HTMLScriptElement>
+    script:
+      | ScriptHTMLAttributes<HTMLScriptElement>
+      | ScriptHTMLAttributesWithHandler<HTMLScriptElement>
     /**
      * @url https://developer.mozilla.org/en-US/docs/Web/HTML/Element/search
      * @url https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement

package/src/index.ts

@@ -4,4 +4,5 @@ export * as Entity from "./Entity.ts"
 export * as FileRouter from "./FileRouter.ts"
 export * as Route from "./Route.ts"
 export * as Start from "./Start.ts"
+export * as System from "./System.ts"
 export * as Unique from "./Unique.ts"

package/src/lint/plugin.js

@@ -71,6 +71,117 @@ export default {
       },
     },
 
+    "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",
@@ -274,3 +385,21 @@ function getBaseName(source) {
 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/src/sql/bun/index.ts

@@ -0,0 +1,147 @@
+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.ts"
+
+const errorCode = (error: unknown): string => {
+  const e = error as any
+  if (typeof e?.errno === "string") return e.errno
+  return e?.code ?? "UNKNOWN"
+}
+
+const wrapError = (error: unknown): Sql.SqlError =>
+  new Sql.SqlError({
+    code: errorCode(error),
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+  })
+
+const wrap = <T>(fn: () => PromiseLike<T>): Effect.Effect<T, Sql.SqlError> =>
+  Effect.tryPromise({ try: () => Promise.resolve(fn()), catch: wrapError })
+
+const makeValues: Sql.SqlQuery["values"] = (obj: any, ...columns: Array<string>) => {
+  const items = Array.isArray(obj) ? obj : [obj]
+  const cols = columns.length > 0 ? columns : Object.keys(items[0])
+  return { value: items, columns: cols }
+}
+
+interface TxState {
+  readonly conn: any
+  readonly depth: number
+}
+
+const currentTransaction = GlobalValue.globalValue(
+  Symbol.for("effect-start/sql/bun/currentTransaction"),
+  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+)
+
+const makeRun =
+  (bunSql: any) =>
+  <T>(fn: (conn: any) => PromiseLike<T>): Effect.Effect<T, Sql.SqlError> =>
+    Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+      wrap(() => fn(Option.isSome(txOpt) ? txOpt.value.conn : bunSql)),
+    )
+
+const makeWithTransaction =
+  (bunSql: any) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Sql.SqlError | E, R> =>
+    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: any) =>
+          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: any) =>
+              Effect.ensuring(
+                runTx(reserved),
+                Effect.sync(() => reserved.release()),
+              ),
+          },
+        )
+      }),
+    )
+
+export const layer = (
+  config: ConstructorParameters<typeof Bun.SQL>[0],
+): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+  Layer.scoped(
+    Sql.SqlClient,
+    Effect.acquireRelease(
+      Effect.try({
+        try: () => {
+          const bunSql = new Bun.SQL(config as any)
+          const run = makeRun(bunSql)
+          const use: Sql.SqlClient["use"] = (fn) =>
+            Effect.tryPromise({ try: () => Promise.resolve(fn(bunSql)), catch: wrapError })
+          return Object.assign(
+            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
+              run<ReadonlyArray<T>>((conn) => conn(strings, ...values)),
+            {
+              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
+                run<ReadonlyArray<T>>((conn) => conn.unsafe(query, values)),
+              values: makeValues,
+              withTransaction: makeWithTransaction(bunSql),
+              reserve: Effect.acquireRelease(
+                wrap(() => bunSql.reserve()),
+                (reserved: any) => Effect.sync(() => reserved.release()),
+              ).pipe(
+                Effect.map(
+                  (reserved: any): Sql.SqlQuery =>
+                    Object.assign(
+                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
+                        wrap<ReadonlyArray<T>>(() => reserved(strings, ...values)),
+                      {
+                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
+                          wrap<ReadonlyArray<T>>(() => reserved.unsafe(query, values)),
+                        values: makeValues,
+                      },
+                    ),
+                ),
+              ),
+              close: (options?: { readonly timeout?: number }) =>
+                use((bunSql) => bunSql.close(options)),
+              use,
+            },
+          ) satisfies Sql.SqlClient
+        },
+        catch: wrapError,
+      }),
+      (client) => client.close().pipe(Effect.orDie),
+    ),
+  )

package/src/sql/mssql/docker.ts

@@ -0,0 +1,117 @@
+import * as Effect from "effect/Effect"
+import * as Stream from "effect/Stream"
+
+import type * as ChildProcess from "../../ChildProcess.ts"
+import type * as PlatformError from "../../PlatformError.ts"
+import type * as Mssql from "mssql"
+import * as System from "../../System.ts"
+import * as BunChildProcessSpawner from "../../bun/BunChildProcessSpawner.ts"
+
+const PORT = 1433
+const PASSWORD = "TestPass123"
+const CONTAINER = "effect-start-mssql"
+
+const exec = (
+  ...args: Array<string>
+): Effect.Effect<number, PlatformError.PlatformError, ChildProcess.ChildProcessSpawner> =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const handle = yield* System.spawn("docker", args, {
+        stdout: "ignore",
+        stderr: "inherit",
+      })
+      return yield* handle.exitCode
+    }),
+  )
+
+const execStdout = (
+  ...args: Array<string>
+): Effect.Effect<string, PlatformError.PlatformError, ChildProcess.ChildProcessSpawner> =>
+  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)
+
+type MssqlModule = {
+  ConnectionPool: new (config: Mssql.config) => Mssql.ConnectionPool
+}
+
+const loadMssql = () => import("mssql") as Promise<MssqlModule>
+
+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 as const,
+}).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.Effect<void, unknown, ChildProcess.ChildProcessSpawner>) =>
+  Effect.runPromise(Effect.provide(effect, BunChildProcessSpawner.layer))
+
+export const start = () => run(program)
+
+export const stop = () => run(removeContainer)