@effect-app/infra 2.0.1 → 2.1.0

package/src/fileUtil.ts

@@ -0,0 +1,85 @@
+import crypto from "crypto"
+import { Effect } from "effect-app"
+import type { Abortable } from "events"
+import type { Mode, ObjectEncodingOptions, OpenMode } from "fs"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import type internal from "stream"
+
+export function readFile(fileName: string) {
+  return Effect.tryPromise(() => fs.readFile(fileName))
+}
+
+export function createReadableStream(fileName: string) {
+  return Effect.map(openFile(fileName), (file) => file.createReadStream())
+}
+
+export function openFile(fileName: string) {
+  return Effect.acquireRelease(Effect.tryPromise(() => fs.open(fileName)), (f) => Effect.promise(() => f.close()))
+}
+
+export function tempFile(
+  folder: string
+) {
+  return (prefix: string) => (data: Data, options?: FileOptions) => tempFile_(folder, prefix, data, options)
+}
+
+type Data =
+  | string
+  | NodeJS.ArrayBufferView
+  | Iterable<string | NodeJS.ArrayBufferView>
+  | AsyncIterable<string | NodeJS.ArrayBufferView>
+  | internal.Stream
+
+export type FileOptions =
+  | (ObjectEncodingOptions & {
+    mode?: Mode | undefined
+    flag?: OpenMode | undefined
+  } & Abortable)
+  | BufferEncoding
+  | null
+export function tempFile_(
+  folder: string,
+  prefix: string,
+  data: Data,
+  options?: FileOptions
+) {
+  return Effect.flatMap(
+    Effect
+      .sync(() => path.join(os.tmpdir(), folder, `${prefix}-` + crypto.randomUUID())),
+    (fp) =>
+      Effect.acquireRelease(
+        Effect
+          .map(
+            Effect
+              .tryPromise(() => fs.writeFile(fp, data, options)),
+            (_) => fp
+          ),
+        (p) => Effect.promise(() => fs.unlink(p))
+      )
+  )
+}
+
+/**
+ * Safe write file to .tmp and then rename
+ */
+export function writeTextFile(fileName: string, content: string) {
+  const tmp = fileName + ".tmp"
+  return Effect
+    .andThen(
+      Effect
+        .tryPromise(() => fs.writeFile(tmp, content, "utf-8")),
+      Effect.tryPromise(() => fs.rename(tmp, fileName))
+    )
+    .pipe(Effect.orDie)
+}
+
+export function fileExists(fileName: string) {
+  return Effect.orDie(Effect
+    .tryPromise(() => fs.stat(fileName).then((_) => _.isFile())))
+}
+
+export function readTextFile(fileName: string) {
+  return Effect.tryPromise(() => fs.readFile(fileName, "utf-8"))
+}

package/src/logger/shared.ts

@@ -10,9 +10,8 @@ export function getRequestContextFromFiberRefs(fiberRefs: FiberRefs.FiberRefs) {
   const locale = FiberRefs.getOrDefault(fiberRefs, LocaleRef)
   const namespace = FiberRefs.getOrDefault(fiberRefs, storeId)
   return new RequestContext({
-    span: Option.getOrElse(
-      span,
-      () => ({ spanId: "bogus", sampled: true, traceId: "bogus" })
+    span: Option.map(span, Tracer.externalSpan).pipe(
+      Option.getOrElse(() => ({ spanId: "bogus", sampled: true, traceId: "bogus" }))
     ),
     name: NonEmptyString255("_"),
     locale,

package/src/services/CUPS.ts

@@ -0,0 +1,151 @@
+import type { FileOptions } from "@effect-app/infra/fileUtil"
+import { tempFile } from "@effect-app/infra/fileUtil"
+import cp from "child_process"
+import { Config, Effect, Layer, Predicate } from "effect-app"
+import { NonEmptyString255 } from "effect-app/Schema"
+import { pretty } from "effect-app/utils"
+import fs from "fs"
+import os from "os"
+import path from "path"
+import util from "util"
+import { InfraLogger } from "../logger.js"
+
+export const PrinterId = NonEmptyString255
+export type PrinterId = NonEmptyString255
+
+const exec_ = util.promisify(cp.exec)
+const exec = (command: string) =>
+  Effect.andThen(
+    InfraLogger.logDebug(`Executing: ${command}`),
+    Effect.tap(
+      Effect
+        .tryPromise(() => exec_(command)),
+      (r) => (InfraLogger.logDebug(`Executed`).pipe(Effect.annotateLogs("result", pretty(r))))
+    )
+  )
+
+type PrinterConfig = { url?: URL | undefined; id: string }
+
+function printFile(printer: PrinterConfig | undefined, options: string[]) {
+  return (filePath: string) => printFile_(filePath, printer, options)
+}
+
+function printFile_(filePath: string, printer: PrinterConfig | undefined, options: string[]) {
+  return exec(["lp", ...buildPrintArgs(filePath, printer, options)].join(" "))
+}
+
+function* buildPrintArgs(filePath: string, printer: PrinterConfig | undefined, options: string[]) {
+  if (printer) {
+    if (printer.url) {
+      yield `-h ${printer.url.host}`
+      if (printer.url.username) {
+        yield `-U ${printer.url.username}`
+      }
+    }
+    yield `-d "${printer.id}"`
+    for (const o of options) {
+      yield `-o ${o}`
+    }
+  }
+  yield `"${filePath}"`
+}
+
+export const prepareTempDir = Effect.sync(() => {
+  // TODO
+  try {
+    fs.mkdirSync(path.join(os.tmpdir(), "effect-ts-app"))
+  } catch (err) {
+    if (`${err}`.includes("EEXIST")) {
+      return
+    }
+    throw err
+  }
+})
+
+const makeTempFile = tempFile("effect-ts-app")
+export const makePrintJobTempFile = makeTempFile("print-job")
+export const makePrintJobTempFileArrayBuffer = (buffer: ArrayBuffer, options?: FileOptions) =>
+  makePrintJobTempFile(Buffer.from(buffer), options)
+
+function printBuffer(printer: PrinterConfig, options: string[]) {
+  return (buffer: ArrayBuffer) =>
+    makePrintJobTempFileArrayBuffer(buffer)
+      .pipe(
+        Effect.flatMap(printFile(printer, options)),
+        Effect.scoped
+      )
+}
+
+function getAvailablePrinters(host?: string) {
+  return Effect.gen(function*() {
+    const { stdout } = yield* exec(["lpstat", ...buildListArgs({ host }), "-s"].join(" "))
+    return [...stdout.matchAll(/device for (\w+):/g)]
+      .map((_) => _[1])
+      .filter(Predicate.isNotNullable)
+      .map((_) => NonEmptyString255(_))
+  })
+}
+
+function* buildListArgs(config?: { host?: string | undefined }) {
+  if (config?.host) {
+    yield `-h ${config.host}`
+  }
+}
+
+export class CUPS extends Effect.Service<CUPS>()("effect-app/CUPS", {
+  effect: Effect.gen(function*() {
+    const cupsServer = yield* Config.string("cupsServer").pipe(
+      Config.mapAttempt((_) => new URL(_)),
+      Config.withDefault(undefined)
+    )
+    function print(buffer: ArrayBuffer, printerId: PrinterId, ...options: string[]) {
+      const _print = printBuffer({
+        id: printerId,
+        url: cupsServer
+      }, options)
+      return _print(buffer)
+    }
+    return {
+      print,
+      printFile: (filePath: string, printerId: PrinterId, ...options: string[]) =>
+        printFile({
+          id: printerId,
+          url: cupsServer
+        }, options)(filePath),
+      getAvailablePrinters: getAvailablePrinters(cupsServer?.host)
+    }
+  })
+}) {
+  static readonly Fake = Layer.effect(
+    this,
+    Effect.sync(() => {
+      return this.make({
+        print: (buffer, printerId, ...options) =>
+          InfraLogger
+            .logInfo("Printing to fake printer")
+            .pipe(
+              Effect.zipRight(Effect.sync(() => ({ stdout: "fake", stderr: "" }))),
+              Effect
+                .annotateLogs({
+                  printerId,
+                  "options": pretty(options),
+                  "bufferSize": buffer.byteLength.toString()
+                })
+            ),
+        printFile: (filePath, printerId, ...options) =>
+          InfraLogger
+            .logInfo("Printing to fake printer")
+            .pipe(
+              Effect.zipRight(Effect.sync(() => ({ stdout: "fake", stderr: "" }))),
+              Effect
+                .annotateLogs({
+                  printerId,
+                  filePath,
+                  "options": pretty(options)
+                })
+            ),
+        getAvailablePrinters: Effect.sync(() => [])
+      })
+    })
+  )
+}

package/src/services/QueueMaker/SQLQueue.ts

@@ -1,4 +1,3 @@
-import { Model } from "@effect-app/infra-adapters/SQL"
 import { getRequestContext, setupRequestContext } from "@effect-app/infra/api/setupRequest"
 import { reportNonInterruptedFailure } from "@effect-app/infra/services/QueueMaker/errors"
 import type { QueueBase } from "@effect-app/infra/services/QueueMaker/service"
@@ -10,6 +9,7 @@ import { Effect, Fiber, Option, S, Tracer } from "effect-app"
 import type { NonEmptyString255 } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
 import { InfraLogger } from "../../logger.js"
+import { Model } from "../adapters/SQL.js"
 
 export const QueueId = S.Number.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type

package/src/services/QueueMaker/memQueue.ts

@@ -1,9 +1,9 @@
-import { MemQueue } from "@effect-app/infra-adapters/memQueue"
 import { Tracer } from "effect"
 import { Effect, Fiber, flow, S } from "effect-app"
 import { pretty } from "effect-app/utils"
 import { getRequestContext, setupRequestContext } from "../../api/setupRequest.js"
 import { InfraLogger } from "../../logger.js"
+import { MemQueue } from "../adapters/memQueue.js"
 import { reportNonInterruptedFailure } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 

package/src/services/QueueMaker/sbqueue.ts

@@ -1,17 +1,17 @@
 import type {} from "@azure/service-bus"
-import {
-  LiveSender,
-  LiveServiceBusClient,
-  Sender,
-  ServiceBusReceiverFactory,
-  subscribe
-} from "@effect-app/infra-adapters/ServiceBus"
 import { Tracer } from "effect"
 import { Cause, Effect, flow, Layer, S } from "effect-app"
 import type { StringId } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
 import { getRequestContext, setupRequestContext } from "../../api/setupRequest.js"
 import { InfraLogger } from "../../logger.js"
+import {
+  LiveSender,
+  LiveServiceBusClient,
+  Sender,
+  ServiceBusReceiverFactory,
+  subscribe
+} from "../adapters/ServiceBus.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 

package/src/services/Store/Cosmos.ts

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { CosmosClient, CosmosClientLayer } from "@effect-app/infra-adapters/cosmos-client"
 import { Array, Chunk, Duration, Effect, Layer, Option, pipe, Secret, Struct } from "effect-app"
 import type { NonEmptyReadonlyArray } from "effect-app"
 import { toNonEmptyArray } from "effect-app/Array"
 import { dropUndefinedT } from "effect-app/utils"
 import { OptimisticConcurrencyException } from "../../errors.js"
 import { InfraLogger } from "../../logger.js"
+import { CosmosClient, CosmosClientLayer } from "../adapters/cosmos-client.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { StoreMaker } from "./service.js"
 import type { FilterArgs, PersistenceModelType, StorageConfig, Store, StoreConfig } from "./service.js"

package/src/services/Store/Disk.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as fu from "@effect-app/infra-adapters/fileUtil"
+import * as fu from "../../fileUtil.js"
 
 import fs from "fs"