effect-start 0.25.0 → 0.27.0

package/src/sql/mssql/index.ts

@@ -5,26 +5,8 @@ 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
-  }
-}
+import * as Sql from "../SqlClient.ts"
+import * as Values from "../../Values.ts"
 
 const wrapError = (error: unknown): Sql.SqlError =>
   new Sql.SqlError({
@@ -35,17 +17,33 @@ const wrapError = (error: unknown): Sql.SqlError =>
     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 dialect = Sql.mssqlDialect
+const makeSpanAttributes = (
+  config: Mssql.config & {
+    readonly url?: string
+    readonly spanAttributes?: Record<string, unknown>
+  },
+): Record<string, unknown> =>
+  {
+    const parsed = (() => {
+      if (typeof config.url !== "string") return undefined
+      try {
+        return new URL(config.url)
+      } catch {
+        return undefined
+      }
+    })()
+    const dbFromPath = parsed?.pathname.replace(/^\/+/, "") || undefined
+    const parsedPort = parsed?.port ? Number(parsed.port) : undefined
 
-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 }
-}
+    return Values.compact({
+      ...(config.spanAttributes ?? {}),
+      "db.system.name": "microsoft.sql_server",
+      "db.namespace": config.database ?? dbFromPath,
+      "server.address": config.server ?? parsed?.hostname,
+      "server.port": config.port ?? parsedPort,
+    })
+  }
 
 const addInputs = (request: Mssql.Request, values: Array<unknown>) => {
   for (let i = 0; i < values.length; i++) {
@@ -53,7 +51,7 @@ const addInputs = (request: Mssql.Request, values: Array<unknown>) => {
   }
 }
 
-interface TxState {
+interface TransactionConnection {
   readonly transaction: Mssql.Transaction
   readonly depth: number
 }
@@ -66,45 +64,71 @@ 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()),
+  () => FiberRef.unsafeMake<Option.Option<TransactionConnection>>(Option.none()),
 )
 
+const makeRequest = (
+  pool: Mssql.ConnectionPool,
+  txOpt: Option.Option<TransactionConnection>,
+  values: Array<unknown>,
+): Mssql.Request => {
+  const request = Option.isSome(txOpt) ? txOpt.value.transaction.request() : pool.request()
+  addInputs(request, values)
+  return request
+}
+
 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),
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => makeRequest(pool, txOpt, values).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)
-}
+    }).pipe(Effect.map((result) => result.recordset ?? [])),
+  )
 
 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),
+  Effect.flatMap(FiberRef.get(currentTransaction), (txOpt) =>
+    Effect.tryPromise({
+      try: () => makeRequest(pool, txOpt, values ?? []).query<T>(query),
       catch: wrapError,
-    }).pipe(Effect.map((result) => result.recordset ?? []))
-  })
+    }).pipe(Effect.map((result) => result.recordset ?? [])),
+  )
+
+const makeTaggedTemplate = (pool: Mssql.ConnectionPool) => {
+  const unsafeFn = <T = any>(query: string, values?: Array<unknown>) =>
+    runUnsafe<T>(pool, query, values)
+
+  return <T = any>(
+    strings: TemplateStringsArray,
+    ...values: Array<unknown>
+  ): Effect.Effect<ReadonlyArray<T>, Sql.SqlError> => {
+    if (Sql.hasFragments(values)) {
+      const compiled = Sql.interpolate(dialect, strings, values)
+      return unsafeFn<T>(compiled.sql, compiled.parameters)
+    }
+
+    let text = strings[0]
+    for (let i = 0; i < values.length; i++) text += `@p${i + 1}` + strings[i + 1]
+    return executeQuery<T>(pool, text, values)
+  }
+}
+
+const makeQuery = (
+  pool: Mssql.ConnectionPool,
+  spanAttributes: ReadonlyArray<readonly [string, unknown]>,
+): Sql.Connection => {
+  const query = makeTaggedTemplate(pool)
+  const unsafe: Sql.Connection["unsafe"] = <T = any>(query: string, values?: Array<unknown>) =>
+    runUnsafe<T>(pool, query, values)
+  return Sql.connection(query, unsafe, { spanAttributes, dialect })
+}
 
 const makeWithTransaction =
   (pool: Mssql.ConnectionPool) =>
@@ -161,63 +185,72 @@ const makeWithTransaction =
       }),
     )
 
-export const layer = (config: MssqlConfig): Layer.Layer<Sql.SqlClient, Sql.SqlError> =>
+export const layer = (
+  config: Mssql.config & {
+    readonly url?: string
+    readonly spanAttributes?: Record<string, unknown>
+  },
+): 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,
-                      },
+    Effect.map(
+      Effect.acquireRelease(
+        Effect.tryPromise({
+          try: async () => {
+            const mssql = await loadMssql()
+            const driverConfig = { ...config } as Record<string, unknown>
+            delete driverConfig.spanAttributes
+            delete driverConfig.url
+            const pool = await new mssql.ConnectionPool(driverConfig as unknown as Mssql.config).connect()
+            return { mssql, pool }
+          },
+          catch: wrapError,
+        }).pipe(
+          Effect.map((options) => {
+            const driverConfig = { ...config } as Record<string, unknown>
+            delete driverConfig.spanAttributes
+            delete driverConfig.url
+            const spanAttributes = Object.entries(makeSpanAttributes(config))
+            const query = makeTaggedTemplate(options.pool)
+            const unsafeFn: Sql.Connection["unsafe"] = <T = any>(
+              query: string,
+              values?: Array<unknown>,
+            ) => runUnsafe<T>(options.pool, query, values)
+            const use: Sql.SqlClient["use"] = (fn) =>
+              Effect.tryPromise({ try: () => Promise.resolve(fn(options.pool)), catch: wrapError })
+
+            return {
+              client: Sql.make({
+                query,
+                unsafe: unsafeFn,
+                withTransaction: makeWithTransaction(options.pool),
+                spanAttributes,
+                dialect,
+                reserve: Effect.acquireRelease(
+                  Effect.tryPromise({
+                    try: () =>
+                      new options.mssql.ConnectionPool({
+                        ...driverConfig,
+                        pool: { max: 1, min: 1 },
+                      } as unknown 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.Connection => makeQuery(reserved, spanAttributes)),
                 ),
-              ),
-              close: () => use((pool) => pool.close()),
-              use,
-            },
-          ) satisfies Sql.SqlClient
-        }),
+                use,
+              }),
+              close: use((pool) => pool.close()),
+            }
+          }),
+        ),
+        (handle) => handle.close.pipe(Effect.orDie),
       ),
-      (client) => client.close().pipe(Effect.orDie),
+      (handle) => handle.client,
     ),
   )

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

@@ -1,3 +1,4 @@
+// types from @types/mssql@9.1.9
 declare module "mssql" {
   export interface config {
     readonly server: string

package/src/testing/TestLogger.ts

@@ -24,13 +24,13 @@ export function layer(): Layer.Layer<TestLogger> {
       const messages = yield* Ref.make<Array<string>>([])
       const mutableRef = (messages as any).ref as MutableRef.MutableRef<Array<string>>
 
-      const customLogger = Logger.make(({ message, logLevel, cause }) => {
-        const causeStr = !Cause.isEmpty(cause)
-          ? ` ${Cause.pretty(cause, { renderErrorCause: true })}`
+      const customLogger = Logger.make((options) => {
+        const causeStr = !Cause.isEmpty(options.cause)
+          ? ` ${Cause.pretty(options.cause, { renderErrorCause: true })}`
           : ""
         MutableRef.update(mutableRef, (msgs) => [
           ...msgs,
-          `[${logLevel._tag}] ${String(message)}${causeStr}`,
+          `[${options.logLevel._tag}] ${String(options.message)}${causeStr}`,
         ])
       })
 

package/src/x/tailwind/compile.ts

@@ -20,24 +20,16 @@ export interface CompileOptions {
   customJsResolver?: Resolver
 }
 
-function createCompileOptions({
-  base,
-  from,
-  polyfills,
-  onDependency,
-
-  customCssResolver,
-  customJsResolver,
-}: CompileOptions) {
+function createCompileOptions(options: CompileOptions) {
   return {
-    base,
-    polyfills,
-    from,
+    base: options.base,
+    polyfills: options.polyfills,
+    from: options.from,
     async loadModule(id: string, base: string) {
-      return loadModule(id, base, onDependency, customJsResolver)
+      return loadModule(id, base, options.onDependency, options.customJsResolver)
     },
     async loadStylesheet(id: string, sheetBase: string) {
-      let sheet = await loadStylesheet(id, sheetBase, onDependency, customCssResolver)
+      let sheet = await loadStylesheet(id, sheetBase, options.onDependency, options.customCssResolver)
 
       return sheet
     },

package/dist/ChildProcess.js

@@ -1,42 +0,0 @@
-/**
- * Adapted from upcomnig Effect 4 aka effect-smol.
- *
- * Kept a minimal interface without tempaltes and file descirptor
- * to keep it compatible if it lands in the core (ie. not in seperate platform package.)
- */
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Pipeable from "effect/Pipeable"
-import * as Predicate from "effect/Predicate"
-import * as Utils from "effect/Utils"
-
-const TypeId = Symbol.for("effect-start/ChildProcess/Command")
-
-const CommandProto = {
-  [TypeId]: TypeId,
-  pipe() {
-    return Pipeable.pipeArguments(this, arguments)
-  },
-  [Symbol.iterator]() {
-    return new Utils.SingleShotGen(new Utils.YieldWrap(spawn(this)))
-  },
-}
-
-export const isCommand = (u) => Predicate.hasProperty(u, TypeId)
-
-export const make = (
-  command,
-  args,
-  options,
-) =>
-  Object.assign(Object.create(CommandProto), {
-    command,
-    args: args ?? [],
-    ...options,
-  })
-
-export class ChildProcessSpawner extends Context.Tag("effect-start/ChildProcessSpawner")() {}
-
-export const spawn = (
-  command,
-) => Effect.flatMap(ChildProcessSpawner, (spawner) => spawner.spawn(command))