npm - effect-start - Versions diffs - 0.9.0 - Mend

effect-start 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/LICENSE +21 -0
package/README.md +109 -0
package/package.json +57 -0
package/src/Bundle.ts +167 -0
package/src/BundleFiles.ts +174 -0
package/src/BundleHttp.test.ts +160 -0
package/src/BundleHttp.ts +259 -0
package/src/Commander.test.ts +1378 -0
package/src/Commander.ts +672 -0
package/src/Datastar.test.ts +267 -0
package/src/Datastar.ts +68 -0
package/src/Effect_HttpRouter.test.ts +570 -0
package/src/EncryptedCookies.test.ts +427 -0
package/src/EncryptedCookies.ts +451 -0
package/src/FileHttpRouter.test.ts +207 -0
package/src/FileHttpRouter.ts +122 -0
package/src/FileRouter.ts +405 -0
package/src/FileRouterCodegen.test.ts +598 -0
package/src/FileRouterCodegen.ts +251 -0
package/src/FileRouter_files.test.ts +64 -0
package/src/FileRouter_path.test.ts +132 -0
package/src/FileRouter_tree.test.ts +126 -0
package/src/FileSystemExtra.ts +102 -0
package/src/HttpAppExtra.ts +127 -0
package/src/Hyper.ts +194 -0
package/src/HyperHtml.test.ts +90 -0
package/src/HyperHtml.ts +139 -0
package/src/HyperNode.ts +37 -0
package/src/JsModule.test.ts +14 -0
package/src/JsModule.ts +116 -0
package/src/PublicDirectory.test.ts +280 -0
package/src/PublicDirectory.ts +108 -0
package/src/Route.test.ts +873 -0
package/src/Route.ts +992 -0
package/src/Router.ts +80 -0
package/src/SseHttpResponse.ts +55 -0
package/src/Start.ts +133 -0
package/src/StartApp.ts +43 -0
package/src/StartHttp.ts +42 -0
package/src/StreamExtra.ts +146 -0
package/src/TestHttpClient.test.ts +54 -0
package/src/TestHttpClient.ts +100 -0
package/src/bun/BunBundle.test.ts +277 -0
package/src/bun/BunBundle.ts +309 -0
package/src/bun/BunBundle_imports.test.ts +50 -0
package/src/bun/BunFullstackServer.ts +45 -0
package/src/bun/BunFullstackServer_httpServer.ts +541 -0
package/src/bun/BunImportTrackerPlugin.test.ts +77 -0
package/src/bun/BunImportTrackerPlugin.ts +97 -0
package/src/bun/BunTailwindPlugin.test.ts +335 -0
package/src/bun/BunTailwindPlugin.ts +322 -0
package/src/bun/BunVirtualFilesPlugin.ts +59 -0
package/src/bun/index.ts +4 -0
package/src/client/Overlay.ts +34 -0
package/src/client/ScrollState.ts +120 -0
package/src/client/index.ts +101 -0
package/src/index.ts +24 -0
package/src/jsx-datastar.d.ts +63 -0
package/src/jsx-runtime.ts +23 -0
package/src/jsx.d.ts +4402 -0
package/src/testing.ts +55 -0
package/src/x/cloudflare/CloudflareTunnel.ts +110 -0
package/src/x/cloudflare/index.ts +1 -0
package/src/x/datastar/Datastar.test.ts +267 -0
package/src/x/datastar/Datastar.ts +68 -0
package/src/x/datastar/index.ts +4 -0
package/src/x/datastar/jsx-datastar.d.ts +63 -0

package/src/bun/BunBundle.test.ts ADDED Viewed

@@ -0,0 +1,277 @@
+import * as BunContext from "@effect/platform-bun/BunContext"
+import * as BunHttpServer from "@effect/platform-bun/BunHttpServer"
+import * as HttpRouter from "@effect/platform/HttpRouter"
+import * as HttpServer from "@effect/platform/HttpServer"
+import * as t from "bun:test"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as NFS from "node:fs/promises"
+import * as NOS from "node:os"
+import * as NPath from "node:path"
+import * as Bundle from "../Bundle.ts"
+import * as BundleHttp from "../BundleHttp.ts"
+import * as TestHttpClient from "../TestHttpClient.ts"
+import * as BunBundle from "./BunBundle.ts"
+t.describe("BunBundle manifest structure", () => {
+  t.it("should generate manifest with inputs and outputs arrays", async () => {
+    const tmpDir = await NFS.mkdtemp(
+      NPath.join(NOS.tmpdir(), "effect-start-test-"),
+    )
+    try {
+      const htmlContent = `<!DOCTYPE html>
+<html>
+<head><title>Test</title></head>
+<body>
+  <div id="app"></div>
+  <script src="./index.ts" type="module"></script>
+</body>
+</html>`
+      const jsContent = `console.log("Hello from test bundle");
+export const greeting = "Hello World";`
+      const htmlPath = NPath.join(tmpDir, "index.html")
+      const jsPath = NPath.join(tmpDir, "index.ts")
+      await NFS.writeFile(htmlPath, htmlContent)
+      await NFS.writeFile(jsPath, jsContent)
+      const bundle = await Effect.runPromise(
+        BunBundle.buildClient({
+          entrypoints: [htmlPath],
+        }),
+      )
+      t
+        .expect(bundle.entrypoints)
+        .toBeObject()
+      t
+        .expect(bundle.artifacts)
+        .toBeArray()
+      t
+        .expect(Object.keys(bundle.entrypoints).length)
+        .toBe(1)
+      t
+        .expect(bundle.artifacts.length)
+        .toBe(3)
+      const entrypointKeys = Object.keys(bundle.entrypoints)
+      const firstEntrypoint = entrypointKeys[0]
+      t
+        .expect(firstEntrypoint)
+        .toBeString()
+      t
+        .expect(bundle.entrypoints[firstEntrypoint])
+        .toBeString()
+      const firstArtifact = bundle.artifacts[0]
+      t
+        .expect(firstArtifact)
+        .toHaveProperty("path")
+      t
+        .expect(firstArtifact)
+        .toHaveProperty("type")
+      t
+        .expect(firstArtifact)
+        .toHaveProperty("size")
+      t
+        .expect(firstArtifact.size)
+        .toBeGreaterThan(0)
+    } finally {
+      await NFS.rm(tmpDir, {
+        recursive: true,
+        force: true,
+      })
+    }
+  })
+  t.it("should serve manifest via HTTP with correct structure", async () => {
+    const tmpDir = await NFS.mkdtemp(
+      NPath.join(NOS.tmpdir(), "effect-start-test-"),
+    )
+    try {
+      const htmlContent = `<!DOCTYPE html>
+<html>
+<head><title>Test App</title></head>
+<body><h1>Test</h1></body>
+</html>`
+      const htmlPath = NPath.join(tmpDir, "app.html")
+      await NFS.writeFile(htmlPath, htmlContent)
+      const testLayer = Layer.effect(
+        Bundle.ClientBundle,
+        BunBundle.buildClient({
+          entrypoints: [htmlPath],
+        }),
+      )
+      const result = await Effect.runPromise(
+        Effect
+          .scoped(
+            Effect.gen(function*() {
+              const App = HttpRouter.empty.pipe(
+                HttpRouter.mountApp(
+                  "/_bundle",
+                  BundleHttp.httpApp(),
+                ),
+              )
+              const Client = TestHttpClient.make(App)
+              const response = yield* Client.get("/_bundle/manifest.json")
+              const manifestText = yield* response.text
+              return JSON.parse(manifestText)
+            }),
+          )
+          .pipe(
+            Effect.provide(testLayer),
+          ),
+      )
+      t
+        .expect(result)
+        .toHaveProperty("entrypoints")
+      t
+        .expect(result)
+        .toHaveProperty("artifacts")
+      t
+        .expect(result.entrypoints)
+        .toBeObject()
+      t
+        .expect(result.artifacts)
+        .toBeArray()
+      t
+        .expect(Object.keys(result.entrypoints).length)
+        .toBe(1)
+      t
+        .expect(result.artifacts.length)
+        .toBe(3)
+      const entrypointKeys = Object.keys(result.entrypoints)
+      const firstKey = entrypointKeys[0]
+      t
+        .expect(firstKey)
+        .toBeString()
+      t
+        .expect(result.entrypoints[firstKey])
+        .toBeString()
+      const artifact = result.artifacts[0]
+      t
+        .expect(artifact)
+        .toHaveProperty("path")
+      t
+        .expect(artifact)
+        .toHaveProperty("type")
+      t
+        .expect(artifact)
+        .toHaveProperty("size")
+    } finally {
+      await NFS.rm(tmpDir, {
+        recursive: true,
+        force: true,
+      })
+    }
+  })
+  t.it("should resolve entrypoints to artifacts correctly", async () => {
+    const tmpDir = await NFS.mkdtemp(
+      NPath.join(NOS.tmpdir(), "effect-start-test-"),
+    )
+    try {
+      const htmlContent = `<!DOCTYPE html>
+<html><body>Test</body></html>`
+      const htmlPath = NPath.join(tmpDir, "test.html")
+      await NFS.writeFile(htmlPath, htmlContent)
+      const bundle = await Effect.runPromise(
+        BunBundle.buildClient({
+          entrypoints: [htmlPath],
+        }),
+      )
+      const entrypointKeys = Object.keys(bundle.entrypoints)
+      const firstEntrypoint = entrypointKeys[0]
+      const expectedOutput = bundle.entrypoints[firstEntrypoint]
+      const resolvedOutput = bundle.resolve(firstEntrypoint)
+      t
+        .expect(resolvedOutput)
+        .toBe(expectedOutput)
+      const artifact = bundle.getArtifact(resolvedOutput!)
+      t
+        .expect(artifact)
+        .not
+        .toBeNull()
+      t
+        .expect(artifact)
+        .toBeTruthy()
+    } finally {
+      await NFS.rm(tmpDir, {
+        recursive: true,
+        force: true,
+      })
+    }
+  })
+  t.it("should include all artifact metadata", async () => {
+    const tmpDir = await NFS.mkdtemp(
+      NPath.join(NOS.tmpdir(), "effect-start-test-"),
+    )
+    try {
+      const jsContent = `export const value = 42;`
+      const jsPath = NPath.join(tmpDir, "module.ts")
+      await NFS.writeFile(jsPath, jsContent)
+      const bundle = await Effect.runPromise(
+        BunBundle.buildClient({
+          entrypoints: [jsPath],
+        }),
+      )
+      const artifact = bundle.artifacts[0]
+      t
+        .expect(artifact.path)
+        .toBeString()
+      t
+        .expect(artifact.type)
+        .toBeString()
+      t
+        .expect(artifact.size)
+        .toBeNumber()
+      t
+        .expect(artifact.type)
+        .toContain("javascript")
+    } finally {
+      await NFS.rm(tmpDir, {
+        recursive: true,
+        force: true,
+      })
+    }
+  })
+})

package/src/bun/BunBundle.ts ADDED Viewed

@@ -0,0 +1,309 @@
+import type {
+  BuildConfig,
+  BuildOutput,
+} from "bun"
+import {
+  Array,
+  Context,
+  Effect,
+  Iterable,
+  Layer,
+  pipe,
+  PubSub,
+  Record,
+  Stream,
+  SynchronizedRef,
+} from "effect"
+import * as NPath from "node:path"
+import type {
+  BundleContext,
+  BundleManifest,
+} from "../Bundle.ts"
+import * as Bundle from "../Bundle.ts"
+import * as FileSystemExtra from "../FileSystemExtra.ts"
+import { BunImportTrackerPlugin } from "./index.ts"
+export type BuildOptions = Omit<
+  BuildConfig,
+  "outdir"
+>
+export const buildClient = (
+  config: BuildOptions | string,
+) => {
+  if (typeof config === "string") {
+    config = {
+      entrypoints: [config],
+    }
+  }
+  const baseConfig: Partial<BuildOptions> = {
+    sourcemap: "linked",
+    naming: {
+      entry: "[name]-[hash].[ext]",
+      chunk: "[name]-[hash].[ext]",
+      asset: "[name]-[hash].[ext]",
+    },
+    packages: "bundle",
+    publicPath: "/_bundle/",
+  } as const
+  const resolvedConfig = {
+    ...baseConfig,
+    target: "browser" as const,
+    ...config,
+  }
+  return build(resolvedConfig)
+}
+export const buildServer = (
+  config: BuildOptions | string,
+) => {
+  if (typeof config === "string") {
+    config = {
+      entrypoints: [config],
+    }
+  }
+  const baseConfig: Partial<BuildOptions> = {
+    sourcemap: "linked",
+    naming: {
+      entry: "[dir]/[name]-[hash].[ext]",
+      chunk: "[name]-[hash].[ext]",
+      asset: "[name]-[hash].[ext]",
+    },
+    packages: "bundle",
+  } as const
+  const resolvedConfig = {
+    ...baseConfig,
+    target: "bun" as const,
+    ...config,
+  }
+  return build(resolvedConfig)
+}
+/**
+ * Given a config, build a bundle and returns every time when effect is executed.
+ */
+export function build(
+  config: BuildOptions,
+): Effect.Effect<BundleContext, Bundle.BundleError> {
+  return Effect.gen(function*() {
+    const output = yield* buildBun(config)
+    const manifest = generateManifestfromBunBundle(
+      config,
+      output,
+    )
+    const artifactsMap = Record.fromIterableBy(
+      output.outputs,
+      (v) => v.path.replace(/^\.\//, ""),
+    )
+    const resolve = (path: string) => {
+      return manifest.entrypoints[path] ?? null
+    }
+    const getArtifact = (path: string): Blob | null => {
+      return artifactsMap[resolve(path)]
+        ?? artifactsMap[path]
+        ?? null
+    }
+    return {
+      ...manifest,
+      resolve,
+      getArtifact,
+    }
+  })
+}
+export function layer<T>(
+  tag: Context.Tag<T, BundleContext>,
+  config: BuildOptions,
+) {
+  return Layer.effect(tag, build(config))
+}
+export function layerDev<T>(
+  tag: Context.Tag<T, BundleContext>,
+  config: BuildOptions,
+) {
+  return Layer.scoped(
+    tag,
+    Effect.gen(function*() {
+      const loadRefKey = "_loadRef"
+      const sharedBundle = yield* build(config)
+      const loadRef = yield* SynchronizedRef.make(null)
+      sharedBundle[loadRefKey] = loadRef
+      sharedBundle.events = yield* PubSub.unbounded<Bundle.BundleEvent>()
+      yield* Effect.fork(
+        pipe(
+          FileSystemExtra.watchSource({
+            filter: FileSystemExtra.filterSourceFiles,
+          }),
+          Stream.map(v =>
+            ({
+              _tag: "Change",
+              path: v.path,
+            }) as Bundle.BundleEvent
+          ),
+          Stream.onError(err =>
+            Effect.logError("Error while watching files", err)
+          ),
+          Stream.runForEach((v) =>
+            pipe(
+              Effect.gen(function*() {
+                yield* Effect.logDebug("Updating bundle: " + tag.key)
+                const newBundle = yield* build(config)
+                Object.assign(sharedBundle, newBundle)
+                // Clean old loaded bundle
+                yield* SynchronizedRef.update(loadRef, () => null)
+                // publish event after the built
+                if (sharedBundle.events) {
+                  yield* PubSub.publish(sharedBundle.events, v)
+                }
+              }),
+              Effect.catchAll(err =>
+                Effect.gen(function*() {
+                  yield* Effect.logError(
+                    "Error while updating bundle",
+                    err,
+                  )
+                  if (sharedBundle.events) {
+                    yield* PubSub.publish(sharedBundle.events, {
+                      _tag: "BuildError",
+                      error: String(err),
+                    })
+                  }
+                })
+              ),
+            )
+          ),
+        ),
+      )
+      return sharedBundle
+    }),
+  )
+}
+/**
+ * Finds common path prefix across provided paths.
+ */
+function getBaseDir(paths: string[]) {
+  if (paths.length === 0) return ""
+  if (paths.length === 1) return NPath.dirname(paths[0])
+  const segmentsList = paths.map((path) =>
+    NPath.dirname(path).split("/").filter(Boolean)
+  )
+  return segmentsList[0]
+    .filter((segment, i) => segmentsList.every((segs) => segs[i] === segment))
+    .reduce((path, seg) => `${path}/${seg}`, "") ?? ""
+}
+/**
+ * Maps entrypoints to their respective build artifacts.
+ * Entrypoint key is trimmed to remove common path prefix.
+ */
+function joinBuildEntrypoints(
+  options: BuildOptions,
+  output: BuildOutput,
+) {
+  const commonPathPrefix = getBaseDir(options.entrypoints) + "/"
+  return pipe(
+    Iterable.zip(
+      options.entrypoints,
+      pipe(
+        output.outputs,
+        // Filter out source maps to properly map artifacts to entrypoints.
+        Iterable.filter((v) =>
+          v.kind !== "sourcemap"
+          && !(v.loader === "html" && v.path.endsWith(".js"))
+        ),
+      ),
+    ),
+    Iterable.map(([entrypoint, artifact]) => {
+      return {
+        shortPath: entrypoint.replace(commonPathPrefix, ""),
+        fullPath: entrypoint,
+        artifact,
+      } as const
+    }),
+  )
+}
+/**
+ * Generate manifest from a build.
+ * Useful for SSR and providing source->artifact path mapping.
+ */
+function generateManifestfromBunBundle(
+  options: BuildOptions,
+  output: BuildOutput,
+  imports?: BunImportTrackerPlugin.ImportMap,
+): BundleManifest {
+  const entrypointArtifacts = joinBuildEntrypoints(options, output)
+  return {
+    entrypoints: pipe(
+      entrypointArtifacts,
+      Iterable.map((v) =>
+        [
+          v.shortPath,
+          v.artifact.path.replace(/^\.\//, ""),
+        ] as const
+      ),
+      Record.fromEntries,
+    ),
+    artifacts: pipe(
+      output.outputs,
+      Iterable.map((v) => {
+        // strip './' prefix
+        const shortPath = v.path.replace(/^\.\//, "")
+        return {
+          path: shortPath,
+          type: v.type,
+          size: v.size,
+          hash: v.hash ?? undefined,
+          imports: imports?.get(v.path),
+        }
+      }),
+      Array.fromIterable,
+    ),
+  }
+}
+function buildBun(
+  config: BuildOptions,
+): Effect.Effect<BuildOutput, Bundle.BundleError, never> {
+  return Object.assign(
+    Effect.gen(function*() {
+      const buildOutput: BuildOutput = yield* Effect.tryPromise({
+        try: () => Bun.build(config),
+        catch: (err: AggregateError | unknown) => {
+          const cause = err instanceof AggregateError
+            ? err.errors?.[0] ?? err
+            : err
+          return new Bundle.BundleError({
+            message: "Failed to Bun.build: " + cause,
+            cause: cause,
+          })
+        },
+      })
+      return buildOutput
+    }),
+  )
+}

package/src/bun/BunBundle_imports.test.ts ADDED Viewed

@@ -0,0 +1,50 @@
+import * as t from "bun:test"
+import { effectFn } from "../testing.ts"
+import * as BunBundle from "./BunBundle.ts"
+import * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
+const effect = effectFn()
+t.it("imports", () =>
+  effect(function*() {
+    const importTracker = BunImportTrackerPlugin.make()
+    yield* BunBundle.build({
+      target: "bun",
+      plugins: [
+        importTracker,
+      ],
+      entrypoints: [
+        Bun.fileURLToPath(import.meta.resolve("./BunBundle_imports.test.ts")),
+      ],
+    })
+    const [
+      e0,
+    ] = importTracker.state.entries()
+    t
+      .expect(
+        e0,
+      )
+      .toEqual([
+        "src/bun/BunBundle_imports.test.ts",
+        [
+          {
+            kind: "import-statement",
+            path: "bun:test",
+          },
+          {
+            kind: "import-statement",
+            path: "src/testing.ts",
+          },
+          {
+            kind: "import-statement",
+            path: "src/bun/BunBundle.ts",
+          },
+          {
+            kind: "import-statement",
+            path: "src/bun/BunImportTrackerPlugin.ts",
+          },
+        ],
+      ])
+  }))

package/src/bun/BunFullstackServer.ts ADDED Viewed

@@ -0,0 +1,45 @@
+import { BunHttpServer } from "@effect/platform-bun"
+import * as Config from "effect/Config"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as httpServer from "./BunFullstackServer_httpServer.ts"
+// As of Bun v1.2.13, these types are not publicy exported.
+type BunServeFuntionOptions = Parameters<
+  typeof Bun.serve<any, {}>
+>[0]
+type DefaultOptions = Parameters<typeof BunHttpServer.make>[0]
+type Options =
+  & DefaultOptions
+  & Omit<BunServeFuntionOptions, "fetch" | "error">
+export const make = (opts: Options) => {
+  return Effect.gen(function*() {
+    const env = yield* Config
+      .string("NODE_ENV")
+      .pipe(Config.option)
+    return httpServer.make({
+      development: Option.getOrNull(env) === "development",
+      ...opts,
+    })
+  })
+}
+export const layer = (opts: Options) => {
+  return Layer.unwrapEffect(
+    Effect.gen(function*() {
+      const env = yield* Config.string("NODE_ENV").pipe(Config.option)
+      const development = Option.getOrNull(env) !== "development"
+      return httpServer.layer({
+        development,
+        ...opts,
+      })
+    }),
+  )
+}