effect-start 0.14.0 → 0.16.0

package/src/experimental/EncryptedCookies.test.ts

@@ -1,11 +1,11 @@
 import * as Cookies from "@effect/platform/Cookies"
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as ConfigProvider from "effect/ConfigProvider"
 import * as Effect from "effect/Effect"
 import * as EncryptedCookies from "./EncryptedCookies.ts"
 
-t.describe(`${EncryptedCookies.encrypt.name}`, () => {
-  t.test("return encrypted string in correct format", async () => {
+test.describe(`${EncryptedCookies.encrypt.name}`, () => {
+  test.test("return encrypted string in correct format", async () => {
     const value = "hello world"
 
     const result = await Effect.runPromise(
@@ -14,20 +14,28 @@ t.describe(`${EncryptedCookies.encrypt.name}`, () => {
 
     // Check format: three base64url segments separated by .
     const segments = result.split(".")
-    t.expect(segments).toHaveLength(3)
+    test
+      .expect(segments)
+      .toHaveLength(3)
 
     // Each segment should be base64url (no +, /, or = characters
     // so cookie values are not escaped)
     segments.forEach((segment: string) => {
-      t.expect(segment).not.toMatch(/[+/=]/)
+      test
+        .expect(segment)
+        .not
+        .toMatch(/[+/=]/)
       // Should be valid base64url that can be decoded
       const base64 = segment.replace(/-/g, "+").replace(/_/g, "/")
       const paddedBase64 = base64 + "=".repeat((4 - base64.length % 4) % 4)
-      t.expect(() => atob(paddedBase64)).not.toThrow()
+      test
+        .expect(() => atob(paddedBase64))
+        .not
+        .toThrow()
     })
   })
 
-  t.test("produce different results for same input due to random IV", async () => {
+  test.test("produce different results for same input due to random IV", async () => {
     const value = "same value"
 
     const result1 = await Effect.runPromise(
@@ -37,34 +45,45 @@ t.describe(`${EncryptedCookies.encrypt.name}`, () => {
       EncryptedCookies.encrypt(value, { secret: "test-secret" }),
     )
 
-    t.expect(result1).not.toBe(result2)
+    test
+      .expect(result1)
+      .not
+      .toBe(result2)
 
     // But both should have correct format
-    t.expect(result1.split(".")).toHaveLength(3)
-    t.expect(result2.split(".")).toHaveLength(3)
+    test
+      .expect(result1.split("."))
+      .toHaveLength(3)
+    test
+      .expect(result2.split("."))
+      .toHaveLength(3)
   })
 
-  t.test("handle empty string", async () => {
+  test.test("handle empty string", async () => {
     const value = ""
 
     const result = await Effect.runPromise(
       EncryptedCookies.encrypt(value, { secret: "test-secret" }),
     )
 
-    t.expect(result.split(".")).toHaveLength(3)
+    test
+      .expect(result.split("."))
+      .toHaveLength(3)
   })
 
-  t.test("handle special characters", async () => {
+  test.test("handle special characters", async () => {
     const value = "hello 世界! @#$%^&*()"
 
     const result = await Effect.runPromise(
       EncryptedCookies.encrypt(value, { secret: "test-secret" }),
     )
 
-    t.expect(result.split(".")).toHaveLength(3)
+    test
+      .expect(result.split("."))
+      .toHaveLength(3)
   })
 
-  t.test("handle object with undefined properties", async () => {
+  test.test("handle object with undefined properties", async () => {
     const value = { id: "some", optional: undefined }
 
     const encrypted = await Effect.runPromise(
@@ -75,12 +94,14 @@ t.describe(`${EncryptedCookies.encrypt.name}`, () => {
     )
 
     // JSON.stringify removes undefined properties
-    t.expect(decrypted).toEqual({ id: "some" })
+    test
+      .expect(decrypted)
+      .toEqual({ id: "some" })
   })
 })
 
-t.describe(`${EncryptedCookies.decrypt.name}`, () => {
-  t.test("decrypt encrypted string successfully", async () => {
+test.describe(`${EncryptedCookies.decrypt.name}`, () => {
+  test.test("decrypt encrypted string successfully", async () => {
     const originalValue = "hello world"
 
     const encrypted = await Effect.runPromise(
@@ -90,10 +111,12 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       EncryptedCookies.decrypt(encrypted, { secret: "test-secret" }),
     )
 
-    t.expect(decrypted).toBe(originalValue)
+    test
+      .expect(decrypted)
+      .toBe(originalValue)
   })
 
-  t.test("handle empty string round-trip", async () => {
+  test.test("handle empty string round-trip", async () => {
     const originalValue = ""
 
     const encrypted = await Effect.runPromise(
@@ -103,10 +126,12 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       EncryptedCookies.decrypt(encrypted, { secret: "test-secret" }),
     )
 
-    t.expect(decrypted).toBe(originalValue)
+    test
+      .expect(decrypted)
+      .toBe(originalValue)
   })
 
-  t.test("handle special characters round-trip", async () => {
+  test.test("handle special characters round-trip", async () => {
     const originalValue = "hello 世界! @#$%^&*()"
 
     const encrypted = await Effect.runPromise(
@@ -116,13 +141,15 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       EncryptedCookies.decrypt(encrypted, { secret: "test-secret" }),
     )
 
-    t.expect(decrypted).toBe(originalValue)
+    test
+      .expect(decrypted)
+      .toBe(originalValue)
   })
 
-  t.test("fail with invalid format", () => {
+  test.test("fail with invalid format", () => {
     const invalidValue = "not-encrypted"
 
-    t
+    test
       .expect(
         Effect.runPromise(
           EncryptedCookies.decrypt(invalidValue, { secret: "test-secret" }),
@@ -132,10 +159,10 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       .toThrow()
   })
 
-  t.test("fail with wrong number of segments", () => {
+  test.test("fail with wrong number of segments", () => {
     const invalidValue = "one.two"
 
-    t
+    test
       .expect(
         Effect.runPromise(
           EncryptedCookies.decrypt(invalidValue, { secret: "test-secret" }),
@@ -145,10 +172,10 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       .toThrow()
   })
 
-  t.test("fail with invalid base64", () => {
+  test.test("fail with invalid base64", () => {
     const invalidValue = "invalid.base64.data"
 
-    t
+    test
       .expect(
         Effect.runPromise(
           EncryptedCookies.decrypt(invalidValue, { secret: "test-secret" }),
@@ -158,8 +185,8 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       .toThrow()
   })
 
-  t.test("fail with null value", () => {
-    t
+  test.test("fail with null value", () => {
+    test
       .expect(
         Effect.runPromise(
           EncryptedCookies.encrypt(null, { secret: "test-secret" }),
@@ -169,8 +196,8 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       .toThrow()
   })
 
-  t.test("fail with undefined value", () => {
-    t
+  test.test("fail with undefined value", () => {
+    test
       .expect(
         Effect.runPromise(
           EncryptedCookies.encrypt(undefined, { secret: "test-secret" }),
@@ -180,8 +207,8 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
       .toThrow()
   })
 
-  t.test("fail with empty encrypted value", () => {
-    t
+  test.test("fail with empty encrypted value", () => {
+    test
       .expect(
         Effect.runPromise(
           EncryptedCookies.decrypt("", { secret: "test-secret" }),
@@ -192,8 +219,8 @@ t.describe(`${EncryptedCookies.decrypt.name}`, () => {
   })
 })
 
-t.describe(`${EncryptedCookies.encryptCookie.name}`, () => {
-  t.test("preserve cookie properties and encrypt value", async () => {
+test.describe(`${EncryptedCookies.encryptCookie.name}`, () => {
+  test.test("preserve cookie properties and encrypt value", async () => {
     const cookie = Cookies.unsafeMakeCookie("test", "hello world")
 
     const result = await Effect.runPromise(
@@ -201,18 +228,25 @@ t.describe(`${EncryptedCookies.encryptCookie.name}`, () => {
     )
 
     // Cookie properties should be preserved
-    t.expect(result.name).toBe("test")
+    test
+      .expect(result.name)
+      .toBe("test")
 
     // Value should be encrypted (different from original)
-    t.expect(result.value).not.toBe("hello world")
+    test
+      .expect(result.value)
+      .not
+      .toBe("hello world")
 
     // Should be in encrypted format
-    t.expect(result.value.split(".")).toHaveLength(3)
+    test
+      .expect(result.value.split("."))
+      .toHaveLength(3)
   })
 })
 
-t.describe(`${EncryptedCookies.decryptCookie.name}`, () => {
-  t.test("preserve cookie properties and decrypt value", async () => {
+test.describe(`${EncryptedCookies.decryptCookie.name}`, () => {
+  test.test("preserve cookie properties and decrypt value", async () => {
     const originalCookie = Cookies.unsafeMakeCookie("test", "hello world")
 
     const encrypted = await Effect.runPromise(
@@ -223,15 +257,19 @@ t.describe(`${EncryptedCookies.decryptCookie.name}`, () => {
     )
 
     // Cookie properties should be preserved
-    t.expect(decrypted.name).toBe("test")
+    test
+      .expect(decrypted.name)
+      .toBe("test")
 
     // Value should be JSON stringified (string values are now always serialized)
-    t.expect(decrypted.value).toBe("\"hello world\"")
+    test
+      .expect(decrypted.value)
+      .toBe("\"hello world\"")
   })
 })
 
-t.describe("service", () => {
-  t.test("service uses pre-calculated key material", async () => {
+test.describe("service", () => {
+  test.test("service uses pre-calculated key material", async () => {
     const testSecret = "test-secret-key"
     const testValue = "hello world"
 
@@ -250,12 +288,19 @@ t.describe("service", () => {
       ),
     )
 
-    t.expect(result.decrypted).toBe(testValue)
-    t.expect(result.encrypted).not.toBe(testValue)
-    t.expect(result.encrypted.split(".")).toHaveLength(3)
+    test
+      .expect(result.decrypted)
+      .toBe(testValue)
+    test
+      .expect(result.encrypted)
+      .not
+      .toBe(testValue)
+    test
+      .expect(result.encrypted.split("."))
+      .toHaveLength(3)
   })
 
-  t.test("service cookie functions work with pre-calculated key", async () => {
+  test.test("service cookie functions work with pre-calculated key", async () => {
     const testSecret = "test-secret-key"
     const originalCookie = Cookies.unsafeMakeCookie("test", "hello world")
 
@@ -274,12 +319,19 @@ t.describe("service", () => {
       ),
     )
 
-    t.expect(result.decrypted.name).toBe("test")
-    t.expect(result.decrypted.value).toBe("\"hello world\"")
-    t.expect(result.encrypted.value).not.toBe("hello world")
+    test
+      .expect(result.decrypted.name)
+      .toBe("test")
+    test
+      .expect(result.decrypted.value)
+      .toBe("\"hello world\"")
+    test
+      .expect(result.encrypted.value)
+      .not
+      .toBe("hello world")
   })
 
-  t.test("functions work with pre-derived keys passed as options", async () => {
+  test.test("functions work with pre-derived keys passed as options", async () => {
     const testSecret = "test-secret-key"
     const testValue = "hello world"
 
@@ -344,14 +396,21 @@ t.describe("service", () => {
 
     const result = await Effect.runPromise(program)
 
-    t.expect(result.decrypted).toBe(testValue)
-    t.expect(result.encrypted).not.toBe(testValue)
-    t.expect(result.encrypted.split(".")).toHaveLength(3)
+    test
+      .expect(result.decrypted)
+      .toBe(testValue)
+    test
+      .expect(result.encrypted)
+      .not
+      .toBe(testValue)
+    test
+      .expect(result.encrypted.split("."))
+      .toHaveLength(3)
   })
 })
 
-t.describe("layerConfig", () => {
-  t.test("succeed with valid SECRET_KEY_BASE", async () => {
+test.describe("layerConfig", () => {
+  test.test("succeed with valid SECRET_KEY_BASE", async () => {
     const validSecret = "a".repeat(40)
 
     const program = Effect.gen(function*() {
@@ -374,10 +433,12 @@ t.describe("layerConfig", () => {
       ),
     )
 
-    t.expect(result).toBe("test")
+    test
+      .expect(result)
+      .toBe("test")
   })
 
-  t.test("fail with short SECRET_KEY_BASE", async () => {
+  test.test("fail with short SECRET_KEY_BASE", async () => {
     const shortSecret = "short"
 
     const program = Effect.gen(function*() {
@@ -385,7 +446,7 @@ t.describe("layerConfig", () => {
       return yield* service.encrypt("test")
     })
 
-    t
+    test
       .expect(
         Effect.runPromise(
           program.pipe(
@@ -404,13 +465,13 @@ t.describe("layerConfig", () => {
       .toThrow("SECRET_KEY_BASE must be at least 40 characters")
   })
 
-  t.test("fail with missing SECRET_KEY_BASE", async () => {
+  test.test("fail with missing SECRET_KEY_BASE", async () => {
     const program = Effect.gen(function*() {
       const service = yield* EncryptedCookies.EncryptedCookies
       return yield* service.encrypt("test")
     })
 
-    t
+    test
       .expect(
         Effect.runPromise(
           program.pipe(

package/src/experimental/SseHttpResponse.ts

@@ -6,7 +6,6 @@ import * as Schedule from "effect/Schedule"
 import * as Stream from "effect/Stream"
 import * as StreamExtra from "../StreamExtra.ts"
 
-
 const DefaultHeartbeatInterval = Duration.seconds(5)
 
 export const make = <T = any>(stream: Stream.Stream<T, any>, options?: {

package/src/hyper/Hyper.ts

@@ -0,0 +1,89 @@
+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 { HyperHooks } from "../x/datastar/index.ts"
+import type { JSX } from "./jsx.d.ts"
+
+type Elements = JSX.IntrinsicElements
+
+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,
+    }
+  })
+}
+
+const NoChildren: ReadonlyArray<never> = Object.freeze([])
+
+type Primitive = string | number | boolean | null | undefined
+
+export type HyperType = string | HyperComponent
+
+export type HyperProps = {
+  [key: string]:
+    | Primitive
+    | ReadonlyArray<Primitive>
+    | HyperNode
+    | HyperNode[]
+    | null
+    | undefined
+}
+
+export type HyperComponent = (
+  props: HyperProps,
+) => HyperNode | Primitive
+
+export interface HyperNode {
+  type: HyperType
+  props: HyperProps
+}
+
+export function h(
+  type: HyperType,
+  props: HyperProps,
+): HyperNode {
+  return {
+    type,
+    props: {
+      ...props,
+      children: props.children ?? NoChildren,
+    },
+  }
+}
+
+export function unsafeUse<Value>(tag: Context.Tag<any, Value>) {
+  const currentFiber = Option.getOrThrow(
+    Fiber.getCurrentFiber(),
+  )
+  const context = currentFiber.currentContext
+
+  return Context.unsafeGet(context, tag)
+}
+
+export type GenericJsxObject = {
+  type: any
+  props: any
+}
+
+export function isGenericJsxObject(value: unknown): value is GenericJsxObject {
+  return typeof value === "object"
+    && value !== null
+    && "type" in value
+    && "props" in value
+}

package/src/{HyperHtml.test.ts → hyper/HyperHtml.test.ts}

@@ -1,8 +1,8 @@
-import * as t from "bun:test"
+import * as test from "bun:test"
 import * as HyperHtml from "./HyperHtml.ts"
 import * as HyperNode from "./HyperNode.ts"
 
-t.it("boolean true attributes render without value (React-like)", () => {
+test.it("boolean true attributes render without value (React-like)", () => {
   const node = HyperNode.make("div", {
     hidden: true,
     disabled: true,
@@ -11,12 +11,12 @@ t.it("boolean true attributes render without value (React-like)", () => {
 
   const html = HyperHtml.renderToString(node)
 
-  t
+  test
     .expect(html)
     .toBe("<div hidden disabled data-active></div>")
 })
 
-t.it("boolean false attributes are omitted", () => {
+test.it("boolean false attributes are omitted", () => {
   const node = HyperNode.make("div", {
     hidden: false,
     disabled: false,
@@ -25,12 +25,12 @@ t.it("boolean false attributes are omitted", () => {
 
   const html = HyperHtml.renderToString(node)
 
-  t
+  test
     .expect(html)
     .toBe("<div></div>")
 })
 
-t.it("string attributes render with values", () => {
+test.it("string attributes render with values", () => {
   const node = HyperNode.make("div", {
     id: "test",
     class: "my-class",
@@ -39,12 +39,12 @@ t.it("string attributes render with values", () => {
 
   const html = HyperHtml.renderToString(node)
 
-  t
+  test
     .expect(html)
     .toBe("<div id=\"test\" class=\"my-class\" data-value=\"hello\"></div>")
 })
 
-t.it("number attributes render with values", () => {
+test.it("number attributes render with values", () => {
   const node = HyperNode.make("input", {
     type: "number",
     min: 0,
@@ -54,12 +54,12 @@ t.it("number attributes render with values", () => {
 
   const html = HyperHtml.renderToString(node)
 
-  t
+  test
     .expect(html)
     .toBe("<input type=\"number\" min=\"0\" max=\"100\" value=\"50\">")
 })
 
-t.it("null and undefined attributes are omitted", () => {
+test.it("null and undefined attributes are omitted", () => {
   const node = HyperNode.make("div", {
     id: null,
     class: undefined,
@@ -68,12 +68,12 @@ t.it("null and undefined attributes are omitted", () => {
 
   const html = HyperHtml.renderToString(node)
 
-  t
+  test
     .expect(html)
     .toBe("<div data-test=\"value\"></div>")
 })
 
-t.it("mixed boolean and string attributes", () => {
+test.it("mixed boolean and string attributes", () => {
   const node = HyperNode.make("input", {
     type: "checkbox",
     checked: true,
@@ -84,7 +84,7 @@ t.it("mixed boolean and string attributes", () => {
 
   const html = HyperHtml.renderToString(node)
 
-  t
+  test
     .expect(html)
     .toBe("<input type=\"checkbox\" checked name=\"test\" value=\"on\">")
 })

package/src/{HyperHtml.ts → hyper/HyperHtml.ts}

@@ -17,10 +17,10 @@
  * }
  */
 
-import type * as Hyper from "./Hyper.tsx"
+import type * as Hyper from "./Hyper.ts"
 import * as HyperNode from "./HyperNode.ts"
-import { JSX } from "./jsx"
 import type * as JsxRuntime from "./jsx-runtime.ts"
+import type { JSX } from "./jsx.d.ts"
 
 const EMPTY_TAGS = [
   "area",

package/src/{jsx.d.ts → hyper/jsx.d.ts}

@@ -1,4 +1,4 @@
-import * as HyperNode from "./HyperNode.ts"
+import * as HyperNode from "./hyper/HyperNode.ts"
 import type { DatastarAttributes } from "./x/datastar/jsx-datastar.ts"
 
 /**

package/src/index.ts

@@ -1,6 +1,5 @@
-export * as Start from "./Start.ts"
-
+export * as Bundle from "./bundler/Bundle.ts"
+export * as Entity from "./Entity.ts"
 export * as FileRouter from "./FileRouter.ts"
 export * as Route from "./Route.ts"
-
-export * as Bundle from "./Bundle.ts"
+export * as Start from "./Start.ts"