effect-start 0.22.0 → 0.23.0

package/src/sql/mssql/index.ts

@@ -0,0 +1,223 @@
+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 type * as Mssql from "mssql"
+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
+  }
+}
+
+const wrapError = (error: unknown): Sql.SqlError =>
+  new Sql.SqlError({
+    code:
+      (error as any)?.code ??
+      ((error as any)?.number != null ? String((error as any).number) : "UNKNOWN"),
+    message: error instanceof Error ? error.message : String(error),
+    cause: error,
+  })
+
+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 }
+}
+
+const buildQuery = (strings: TemplateStringsArray, values: Array<unknown>) => {
+  let text = strings[0]
+  for (let i = 0; i < values.length; i++) text += `@p${i + 1}` + strings[i + 1]
+  return { text, values }
+}
+
+const addInputs = (request: Mssql.Request, values: Array<unknown>) => {
+  for (let i = 0; i < values.length; i++) {
+    request.input(`p${i + 1}`, values[i])
+  }
+}
+
+interface TxState {
+  readonly transaction: Mssql.Transaction
+  readonly depth: number
+}
+
+type MssqlModule = {
+  ConnectionPool: new (config: Mssql.config) => Mssql.ConnectionPool
+}
+
+const loadMssql = () => import("mssql") as Promise<MssqlModule>
+
+const currentTransaction = GlobalValue.globalValue(
+  Symbol.for("effect-start/sql/mssql/currentTransaction"),
+  () => FiberRef.unsafeMake<Option.Option<TxState>>(Option.none()),
+)
+
+const executeQuery = <T>(
+  pool: Mssql.ConnectionPool,
+  text: string,
+  values: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
+    addInputs(request, values)
+    return Effect.tryPromise({
+      try: () => request.query<T>(text),
+      catch: wrapError,
+    }).pipe(Effect.map((result) => result.recordset ?? []))
+  })
+
+const runQuery = <T>(
+  pool: Mssql.ConnectionPool,
+  strings: TemplateStringsArray,
+  values: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
+  const { text, values: params } = buildQuery(strings, values)
+  return executeQuery(pool, text, params)
+}
+
+const runUnsafe = <T>(
+  pool: Mssql.ConnectionPool,
+  query: string,
+  values?: Array<unknown>,
+): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> =>
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) => {
+    const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
+    if (values) addInputs(request, values)
+    return Effect.tryPromise({
+      try: () => request.query<T>(query),
+      catch: wrapError,
+    }).pipe(Effect.map((result) => result.recordset ?? []))
+  })
+
+const makeWithTransaction =
+  (pool: Mssql.ConnectionPool) =>
+  <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 { transaction, depth } = txOpt.value
+          const name = `sp_${depth}`
+          return Effect.gen(function* () {
+            const req = transaction.request()
+            yield* Effect.tryPromise({
+              try: () => req.query(`SAVE TRANSACTION ${name}`),
+              catch: wrapError,
+            })
+            const exit = yield* Effect.exit(
+              restore(
+                Effect.locally(
+                  self,
+                  currentTransaction,
+                  Option.some({ transaction, depth: depth + 1 }),
+                ),
+              ),
+            )
+            if (Exit.isSuccess(exit)) {
+              return exit.value
+            }
+            const rbReq = transaction.request()
+            yield* Effect.tryPromise({
+              try: () => rbReq.query(`ROLLBACK TRANSACTION ${name}`),
+              catch: wrapError,
+            }).pipe(Effect.orDie)
+            return yield* exit
+          })
+        }
+
+        return Effect.gen(function* () {
+          const transaction = pool.transaction()
+          yield* Effect.tryPromise({ try: () => transaction.begin(), catch: wrapError })
+          const exit = yield* Effect.exit(
+            restore(
+              Effect.locally(self, currentTransaction, Option.some({ transaction, depth: 1 })),
+            ),
+          )
+          if (Exit.isSuccess(exit)) {
+            yield* Effect.tryPromise({ try: () => transaction.commit(), catch: wrapError })
+            return exit.value
+          }
+          yield* Effect.tryPromise({ try: () => transaction.rollback(), catch: wrapError }).pipe(
+            Effect.orDie,
+          )
+          return yield* exit
+        })
+      }),
+    )
+
+export const layer = (config: MssqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+  Layer.scoped(
+    Sql.SqlClient,
+    Effect.acquireRelease(
+      Effect.tryPromise({
+        try: async () => {
+          const mssql = await loadMssql()
+          const pool = await new mssql.ConnectionPool(config as Mssql.config).connect()
+          return { mssql, pool }
+        },
+        catch: wrapError,
+      }).pipe(
+        Effect.map(({ mssql, pool }) => {
+          const use: Sql.SqlClient["use"] = (fn) =>
+            Effect.tryPromise({ try: () => Promise.resolve(fn(pool)), catch: wrapError })
+          return Object.assign(
+            <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
+              runQuery<T>(pool, strings, values),
+            {
+              unsafe: <T = any>(query: string, values?: Array<unknown>) =>
+                runUnsafe<T>(pool, query, values),
+              values: makeValues,
+              withTransaction: makeWithTransaction(pool),
+              reserve: Effect.acquireRelease(
+                Effect.tryPromise({
+                  try: () =>
+                    new mssql.ConnectionPool({
+                      ...config,
+                      pool: { max: 1, min: 1 },
+                    } as Mssql.config).connect(),
+                  catch: wrapError,
+                }),
+                (reserved: Mssql.ConnectionPool) =>
+                  Effect.tryPromise({ try: () => reserved.close(), catch: () => void 0 }).pipe(
+                    Effect.asVoid,
+                    Effect.orDie,
+                  ),
+              ).pipe(
+                Effect.map(
+                  (reserved): Sql.SqlQuery =>
+                    Object.assign(
+                      <T = any>(strings: TemplateStringsArray, ...values: Array<unknown>) =>
+                        runQuery<T>(reserved, strings, values),
+                      {
+                        unsafe: <T = any>(query: string, values?: Array<unknown>) =>
+                          runUnsafe<T>(reserved, query, values),
+                        values: makeValues,
+                      },
+                    ),
+                ),
+              ),
+              close: () => use((pool) => pool.close()),
+              use,
+            },
+          ) satisfies Sql.SqlClient
+        }),
+      ),
+      (client) => client.close().pipe(Effect.orDie),
+    ),
+  )

package/src/sql/mssql/mssql.d.ts

@@ -0,0 +1,41 @@
+declare module "mssql" {
+  export interface config {
+    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
+      readonly connectTimeout?: number
+    }
+  }
+
+  export class ConnectionPool {
+    constructor(config: config)
+    connect(): Promise<ConnectionPool>
+    close(): Promise<void>
+    request(): Request
+    transaction(): Transaction
+  }
+
+  export class Request {
+    input(name: string, value: unknown): Request
+    query<T>(query: string): Promise<{ recordset?: ReadonlyArray<T> }>
+  }
+
+  export class Transaction {
+    begin(): Promise<void>
+    commit(): Promise<void>
+    rollback(): Promise<void>
+    request(): Request
+  }
+}

package/src/x/cloudflare/CloudflareTunnel.ts

@@ -1,19 +1,5 @@
-import {
-  Config,
-  Data,
-  Effect,
-  identity,
-  Layer,
-  LogLevel,
-  Option,
-  pipe,
-  Stream,
-  String,
-} from "effect"
-
-export class CloudflareTunnelSpawnError extends Data.TaggedError("CloudflareTunnelSpawnError")<{
-  cause: unknown
-}> {}
+import * as System from "../../System.ts"
+import { Config, Effect, Layer, LogLevel, Option, pipe, Stream, String } from "effect"
 
 export const start = (opts: {
   command?: string
@@ -24,6 +10,8 @@ export const start = (opts: {
   logPrefix?: string
 }) =>
   Effect.gen(function* () {
+    const command = opts.command ?? "cloudflared"
+    yield* System.which(command)
     const logPrefix = String.isString(opts.logPrefix) ? opts.logPrefix : "CloudflareTunnel: "
     const args: Array<string> = [
       "tunnel",
@@ -32,20 +20,7 @@ export const start = (opts: {
       opts.tunnelName,
     ].flatMap((v) => v)
 
-    const proc = yield* Effect.try({
-      try: () =>
-        Bun.spawn([opts.command ?? "cloudflared", ...args], {
-          stderr: "pipe",
-          stdout: "pipe",
-        }),
-      catch: (err) => new CloudflareTunnelSpawnError({ cause: err }),
-    })
-
-    yield* Effect.addFinalizer(() =>
-      Effect.sync(() => {
-        proc.kill()
-      }),
-    )
+    const proc = yield* System.spawn(command, args)
 
     yield* Effect.logInfo(
       `Cloudflare tunnel started name=${opts.tunnelName} pid=${proc.pid} tunnelUrl=${
@@ -54,16 +29,13 @@ export const start = (opts: {
     )
 
     yield* pipe(
-      Stream.merge(
-        Stream.fromReadableStream(() => proc.stdout, identity),
-        Stream.fromReadableStream(() => proc.stderr, identity),
-      ),
+      Stream.merge(proc.stdout, proc.stderr),
       Stream.decodeText("utf-8"),
       Stream.splitLines,
       (opts.cleanLogs ?? true)
         ? Stream.map((v) => v.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s\w+\s/, ""))
-        : identity,
-      logPrefix ? Stream.map((v) => logPrefix + v) : identity,
+        : (s) => s,
+      logPrefix ? Stream.map((v) => logPrefix + v) : (s) => s,
       Stream.runForEach((v) => Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)),
     )
   })

package/src/x/tailscale/TailscaleTunnel.ts

@@ -0,0 +1,113 @@
+import * as BunServer from "../../bun/BunServer.ts"
+import * as PlatformError from "../../PlatformError.ts"
+import * as System from "../../System.ts"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as LogLevel from "effect/LogLevel"
+import * as Stream from "effect/Stream"
+import * as Function from "effect/Function"
+
+interface TailscaleStatus {
+  readonly BackendState: string
+  readonly Self?: {
+    readonly DNSName?: string
+    readonly TailscaleIPs?: ReadonlyArray<string>
+  }
+}
+
+const getStatus = (command: string) =>
+  Effect.gen(function* () {
+    const proc = yield* System.spawn(command, ["status", "--json"])
+    const exitCode = yield* proc.exitCode
+
+    if (exitCode !== 0) {
+      const stderr = yield* proc.stderr.pipe(Stream.decodeText("utf-8"), Stream.mkString)
+      return yield* new PlatformError.SystemError({
+        reason: "Unknown",
+        module: "TailscaleTunnel",
+        method: "getStatus",
+        description: `tailscale status exited with code ${exitCode}: ${stderr}`,
+      })
+    }
+
+    const stdout = yield* proc.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString)
+    const json: TailscaleStatus = JSON.parse(stdout)
+
+    if (json.BackendState !== "Running") {
+      return yield* new PlatformError.SystemError({
+        reason: "Unknown",
+        module: "TailscaleTunnel",
+        method: "getStatus",
+        description: `tailscale is in state "${json.BackendState}", expected "Running"`,
+      })
+    }
+
+    return json
+  })
+
+const serve = (opts: {
+  command: string
+  port: number
+  dnsName?: string
+  public?: boolean
+  logLevel?: LogLevel.LogLevel
+  logPrefix?: string
+}) =>
+  Effect.gen(function* () {
+    const logPrefix = opts.logPrefix ?? "TailscaleTunnel: "
+    const args = [opts.public ? "funnel" : "serve", String(opts.port)]
+
+    const proc = yield* System.spawn(opts.command, args)
+
+    yield* Function.pipe(
+      Stream.merge(proc.stdout, proc.stderr),
+      Stream.decodeText("utf-8"),
+      Stream.splitLines,
+      logPrefix ? Stream.map((v) => logPrefix + v) : (s) => s,
+      Stream.runForEach((v) => Effect.logWithLevel(opts.logLevel ?? LogLevel.Debug, v)),
+    )
+  })
+
+export const start = (opts: {
+  command?: string
+  port: number
+  public?: boolean
+  logLevel?: LogLevel.LogLevel
+  logPrefix?: string
+}) =>
+  Effect.gen(function* () {
+    const command = opts.command ?? "tailscale"
+    yield* System.which(command)
+    const status = yield* getStatus(command)
+    const dnsName = status.Self?.DNSName?.replace(/\.$/, "")
+    yield* serve({ ...opts, command, dnsName })
+  })
+
+export const layer = (opts?: { public?: boolean }) =>
+  Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const { server } = yield* BunServer.BunServer
+      const port = server.port!
+      const command = "tailscale"
+
+      yield* Effect.forkScoped(
+        Effect.gen(function* () {
+          yield* System.which(command)
+          const status = yield* getStatus(command)
+          const dnsName = status.Self?.DNSName?.replace(/\.$/, "")
+
+          const serveUrl = dnsName ? `https://${dnsName}` : undefined
+          yield* Effect.logInfo(
+            `Tailscale ${opts?.public ? "funnel" : "serve"}${serveUrl ? ` url=${serveUrl}` : ""}`,
+          )
+
+          yield* serve({
+            command,
+            port,
+            dnsName,
+            public: opts?.public,
+          })
+        }).pipe(Effect.tapError((e) => Effect.logError(`Tailscale: ${e.description}`))),
+      )
+    }),
+  )

package/src/x/tailscale/index.ts

@@ -0,0 +1 @@
+export * as TailscaleTunnel from "./TailscaleTunnel.ts"

package/src/x/datastar/Datastar.ts

@@ -1,61 +0,0 @@
-import type * as HyperNode from "../../hyper/HyperNode.ts"
-
-export const HyperHooks = {
-  onNode,
-} as const
-
-function onNode(node: HyperNode.HyperNode) {
-  const {
-    "data-signals": dataSignals,
-    "data-class": dataClass,
-    "data-attr": dataAttr,
-    "data-style": dataStyle,
-    "data-show": dataShow,
-    "data-ignore": dataIgnore,
-    "data-ignore-morph": dataIgnoreMorph,
-  } = node.props as any
-
-  if (typeof dataSignals === "object" && dataSignals !== null) {
-    node.props["data-signals"] = JSON.stringify(dataSignals)
-  }
-
-  if (typeof dataClass === "function") {
-    node.props["data-class"] = `(${dataClass.toString()})()`
-  } else if (typeof dataClass === "object" && dataClass !== null) {
-    node.props["data-class"] = JSON.stringify(dataClass)
-  }
-
-  if (typeof dataAttr === "object" && dataAttr !== null) {
-    node.props["data-attr"] = JSON.stringify(dataAttr)
-  }
-
-  if (typeof dataStyle === "function") {
-    node.props["data-style"] = `(${dataStyle.toString()})()`
-  } else if (typeof dataStyle === "object" && dataStyle !== null) {
-    node.props["data-style"] = JSON.stringify(dataStyle)
-  }
-
-  if (typeof dataShow === "boolean") {
-    node.props["data-show"] = dataShow.toString()
-  }
-
-  if (dataIgnore !== true && dataIgnore !== undefined) {
-    delete node.props["data-ignore"]
-  }
-
-  if (dataIgnoreMorph !== true && dataIgnoreMorph !== undefined) {
-    delete node.props["data-ignore-morph"]
-  }
-
-  // Handle dynamic attributes with suffixes
-  for (const [key, value] of Object.entries(node.props)) {
-    if (key.startsWith("data-signals-") && typeof value === "object" && value !== null) {
-      node.props[key] = JSON.stringify(value)
-    }
-
-    if (key.startsWith("data-on-") && typeof value === "function") {
-      // @ts-ignore
-      node.props[key] = `(${value.toString()})()`
-    }
-  }
-}

package/src/x/datastar/index.ts

@@ -1,2 +0,0 @@
-export * as Datastar from "./Datastar.ts"
-export { HyperHooks } from "./Datastar.ts"

package/src/x/datastar/jsx-datastar.d.ts

@@ -1,60 +0,0 @@
-// Datastar object types for specific attributes
-type DatastarSignalsObject = Record<string, any>
-type DatastarClassObject = Record<string, boolean | string>
-type DatastarAttrObject = Record<string, string | boolean | number>
-type DatastarStyleObject = Record<string, string | number | boolean | null | undefined>
-
-/**
- * Datastar attributes for reactive web applications
- * @see https://data-star.dev/reference/attributes
- */
-export interface DatastarAttributes {
-  // Core attributes that can accept objects (but also strings)
-  "data-signals"?: string | DatastarSignalsObject | undefined
-  "data-class"?: string | DatastarClassObject | undefined
-  "data-attr"?: string | DatastarAttrObject | undefined
-  "data-style"?: Function | string | DatastarStyleObject | undefined
-
-  // Boolean/presence attributes (but also strings)
-  "data-show"?: string | boolean | undefined
-  "data-ignore"?: string | boolean | undefined
-  "data-ignore-morph"?: string | boolean | undefined
-
-  // All other Datastar attributes as strings only
-  "data-bind"?: string | undefined
-  "data-computed"?: string | undefined
-  "data-effect"?: string | undefined
-  "data-indicator"?: string | undefined
-  "data-json-signals"?: string | undefined
-  "data-on"?: string | undefined
-  "data-on-intersect"?: string | undefined
-  "data-on-interval"?: string | undefined
-  "data-on-load"?: string | undefined
-  "data-on-signal-patch"?: string | undefined
-  "data-on-signal-patch-filter"?: string | undefined
-  "data-preserve-attr"?: string | undefined
-  "data-ref"?: string | undefined
-  "data-text"?: string | undefined
-
-  // Pro attributes (strings only)
-  "data-animate"?: string | undefined
-  "data-custom-validity"?: string | undefined
-  "data-on-raf"?: string | undefined
-  "data-on-resize"?: string | undefined
-  "data-persist"?: string | undefined
-  "data-query-string"?: string | undefined
-  "data-replace-url"?: string | undefined
-  "data-scroll-into-view"?: string | undefined
-  "data-view-transition"?: string | undefined
-
-  // Dynamic attributes with suffixes
-  [key: `data-signals-${string}`]: string | undefined
-  [key: `data-class-${string}`]: string | undefined
-  [key: `data-attr-${string}`]: string | undefined
-  [key: `data-style-${string}`]: string | undefined
-  [key: `data-bind-${string}`]: string | undefined
-  [key: `data-computed-${string}`]: string | undefined
-  [key: `data-indicator-${string}`]: string | undefined
-  [key: `data-ref-${string}`]: string | undefined
-  [key: `data-on-${string}`]: Function | string | undefined
-}