@planet-matrix/mobius-model 0.6.0 → 0.10.1

package/tests/unit/request/request/base.spec.ts

@@ -0,0 +1,382 @@
+import { expect, test } from "vitest"
+
+import { BaseFetch, BaseRequest } from "#Source/request/index.ts"
+import type { BaseFetchOptions, FetchFactory, Resource } from "#Source/request/index.ts"
+
+type ExampleSuccessOutput = {
+  status: "success"
+  data: {
+    users: string[]
+  }
+}
+
+type ExampleErrorOutput = {
+  status: "error"
+  data: {
+    message: string
+  }
+}
+
+type ExamplePatchOutput = {
+  status: "patch"
+  errorKind: "network" | "unknown"
+  message: string
+}
+
+type ExampleResource = Resource & {
+  baseUrl: "https://api.example.com"
+  path: "/users"
+  method: "get"
+  input: {
+    query: {
+      page: number
+    }
+    body?: undefined
+  }
+  output: ExampleSuccessOutput | ExampleErrorOutput
+  successOutput: ExampleSuccessOutput
+  successData: ExampleSuccessOutput["data"]
+  errorOutput: ExampleErrorOutput
+  errorData: ExampleErrorOutput["data"]
+  patchOutput: ExamplePatchOutput
+}
+
+class TestRequest extends BaseRequest<ExampleResource> {
+  //
+}
+
+class TestResolvedFetch<T> extends BaseFetch<
+  { query: ExampleResource["input"]["query"]; body: ExampleResource["input"]["body"] },
+  { type: "json"; data: T }
+> {
+  constructor(value: T) {
+    const options: BaseFetchOptions<
+      { query: ExampleResource["input"]["query"]; body: ExampleResource["input"]["body"] },
+      { type: "json"; data: T }
+    > = {
+      baseUrl: "https://api.example.com",
+      path: "/users",
+      method: "get",
+    }
+    super(options)
+    this.value = value
+  }
+
+  private value: T
+
+  async getJson(): Promise<T> {
+    return await Promise.resolve(this.value)
+  }
+
+  async getText(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+
+  async getBlob(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+
+  async getArrayBuffer(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+
+  async getStream(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+}
+
+class TestRejectingFetch extends BaseFetch<
+  { query: ExampleResource["input"]["query"]; body: ExampleResource["input"]["body"] },
+  { type: "json"; data: never }
+> {
+  constructor(exception: unknown) {
+    const options: BaseFetchOptions<
+      { query: ExampleResource["input"]["query"]; body: ExampleResource["input"]["body"] },
+      { type: "json"; data: never }
+    > = {
+      baseUrl: "https://api.example.com",
+      path: "/users",
+      method: "get",
+    }
+    super(options)
+    this.exception = exception
+  }
+
+  private exception: unknown
+
+  async getJson(): Promise<never> {
+    await Promise.resolve()
+    throw this.exception
+  }
+
+  async getText(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+
+  async getBlob(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+
+  async getArrayBuffer(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+
+  async getStream(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in request tests.")
+  }
+}
+
+test("BaseRequest.request emits lifecycle callbacks and events for success and error JSON outputs", async () => {
+  const successOutput: ExampleSuccessOutput = {
+    status: "success",
+    data: {
+      users: ["neo", "trinity"]
+    }
+  }
+  const errorOutput: ExampleErrorOutput = {
+    status: "error",
+    data: {
+      message: "denied"
+    }
+  }
+  let getFetchCallCount: number = 0
+  const getFetchCalls: BaseFetchOptions[] = []
+  const getFetch = (options: BaseFetchOptions): TestResolvedFetch<ExampleSuccessOutput> | TestResolvedFetch<ExampleErrorOutput> => {
+    getFetchCallCount = getFetchCallCount + 1
+    getFetchCalls.push(options)
+
+    if (getFetchCallCount === 1) {
+      return new TestResolvedFetch(successOutput)
+    }
+
+    return new TestResolvedFetch(errorOutput)
+  }
+  let modifyRequestOptionsCallCount: number = 0
+  const modifyRequestOptions = (options: {
+    baseUrl: ExampleResource["baseUrl"]
+    path: ExampleResource["path"]
+    method: ExampleResource["method"]
+    headers?: Record<string, string> | undefined
+    query: ExampleResource["input"]["query"]
+  }): {
+    baseUrl: ExampleResource["baseUrl"]
+    path: ExampleResource["path"]
+    method: ExampleResource["method"]
+    headers: Record<string, string>
+    query: ExampleResource["input"]["query"]
+  } => {
+    modifyRequestOptionsCallCount = modifyRequestOptionsCallCount + 1
+
+    return {
+      ...options,
+      headers: {
+        ...options.headers,
+        "X-Trace": "enabled"
+      }
+    }
+  }
+  const request = new TestRequest({
+    fetchFactory: getFetch as unknown as FetchFactory,
+    modifyRequestOptions,
+    generatePatchOutput: ({ errorKind, error }) => {
+      return {
+        status: "patch",
+        errorKind,
+        message: error.message,
+      }
+    }
+  })
+
+  const emittedOutputs: Array<ExampleSuccessOutput | ExampleErrorOutput> = []
+  const emittedSuccessOutputs: ExampleSuccessOutput[] = []
+  const emittedSuccessData: Array<ExampleSuccessOutput["data"]> = []
+  const emittedErrorOutputs: ExampleErrorOutput[] = []
+  const emittedErrorData: Array<ExampleErrorOutput["data"]> = []
+  request.event.subscribe("output", (output) => {
+    emittedOutputs.push(output)
+  })
+  request.event.subscribe("successOutput", (output) => {
+    emittedSuccessOutputs.push(output)
+  })
+  request.event.subscribe("successData", (data) => {
+    emittedSuccessData.push(data)
+  })
+  request.event.subscribe("errorOutput", (output) => {
+    emittedErrorOutputs.push(output)
+  })
+  request.event.subscribe("errorData", (data) => {
+    emittedErrorData.push(data)
+  })
+
+  const callbackOutputs: Array<ExampleSuccessOutput | ExampleErrorOutput> = []
+  const callbackSuccessOutputs: ExampleSuccessOutput[] = []
+  const callbackSuccessData: Array<ExampleSuccessOutput["data"]> = []
+  const callbackErrorOutputs: ExampleErrorOutput[] = []
+  const callbackErrorData: Array<ExampleErrorOutput["data"]> = []
+
+  const successResult = await request.request({
+    baseUrl: "https://api.example.com",
+    path: "/users",
+    method: "get",
+    query: {
+      page: 1
+    },
+    headers: {
+      Authorization: "Bearer token"
+    },
+    onOutput: (output) => {
+      callbackOutputs.push(output)
+    },
+    onSuccessOutput: (output) => {
+      callbackSuccessOutputs.push(output)
+    },
+    onSuccessData: (data) => {
+      callbackSuccessData.push(data)
+    },
+  })
+  const errorResult = await request.request({
+    baseUrl: "https://api.example.com",
+    path: "/users",
+    method: "get",
+    query: {
+      page: 2
+    },
+    onOutput: (output) => {
+      callbackOutputs.push(output)
+    },
+    onErrorOutput: (output) => {
+      callbackErrorOutputs.push(output)
+    },
+    onErrorData: (data) => {
+      callbackErrorData.push(data)
+    },
+  })
+
+  expect(successResult).toEqual(successOutput)
+  expect(errorResult).toEqual(errorOutput)
+  expect(modifyRequestOptionsCallCount).toBe(2)
+  expect(getFetchCallCount).toBe(2)
+  expect(getFetchCalls[0]?.path).toBe("/users")
+  expect(getFetchCalls[0]?.headers?.["Authorization"]).toBe("Bearer token")
+  expect(getFetchCalls[0]?.headers?.["X-Trace"]).toBe("enabled")
+  expect(getFetchCalls[1]?.path).toBe("/users")
+  expect(getFetchCalls[1]?.headers?.["X-Trace"]).toBe("enabled")
+  expect(callbackOutputs).toEqual([successOutput, errorOutput])
+  expect(callbackSuccessOutputs).toEqual([successOutput])
+  expect(callbackSuccessData).toEqual([successOutput.data])
+  expect(callbackErrorOutputs).toEqual([errorOutput])
+  expect(callbackErrorData).toEqual([errorOutput.data])
+  expect(emittedOutputs).toEqual([successOutput, errorOutput])
+  expect(emittedSuccessOutputs).toEqual([successOutput])
+  expect(emittedSuccessData).toEqual([successOutput.data])
+  expect(emittedErrorOutputs).toEqual([errorOutput])
+  expect(emittedErrorData).toEqual([errorOutput.data])
+})
+
+test("BaseRequest.request turns unsupported response types into unknown patch outputs", async () => {
+  const request = new TestRequest({
+    generatePatchOutput: ({ errorKind, error }) => {
+      return {
+        status: "patch",
+        errorKind,
+        message: error.message,
+      }
+    }
+  })
+
+  const result = await request.request({
+    baseUrl: "https://api.example.com",
+    path: "/users",
+    method: "get",
+    query: {
+      page: 1
+    },
+    responseType: "text"
+  })
+
+  expect(result).toEqual({
+    status: "patch",
+    errorKind: "unknown",
+    message: "Unsupported response type, please use \"json\" or improve implementation of BaseRequest.",
+  })
+})
+
+test("BaseRequest.request converts network failures into patch outputs", async () => {
+  const getFetch = (): TestRejectingFetch => {
+    return new TestRejectingFetch(new TypeError("fetch failed"))
+  }
+  const request = new TestRequest({
+    fetchFactory: getFetch as unknown as FetchFactory,
+    generatePatchOutput: ({ errorKind, error }) => {
+      return {
+        status: "patch",
+        errorKind,
+        message: error.message,
+      }
+    }
+  })
+  const patchOutputs: ExamplePatchOutput[] = []
+  request.event.subscribe("patchOutput", (patchOutput) => {
+    patchOutputs.push(patchOutput)
+  })
+
+  const callbackPatchOutputs: ExamplePatchOutput[] = []
+  const result = await request.request({
+    baseUrl: "https://api.example.com",
+    path: "/users",
+    method: "get",
+    query: {
+      page: 1
+    },
+    onPatchOutput: (patchOutput) => {
+      callbackPatchOutputs.push(patchOutput)
+    },
+  })
+
+  expect(result).toEqual({
+    status: "patch",
+    errorKind: "network",
+    message: "fetch failed",
+  })
+  expect(callbackPatchOutputs).toEqual([result])
+  expect(patchOutputs).toEqual([result])
+})
+
+test("BaseRequest.request stringifies non-Error failures into unknown patch outputs", async () => {
+  const getFetch = (): TestRejectingFetch => {
+    return new TestRejectingFetch("boom")
+  }
+  const request = new TestRequest({
+    fetchFactory: getFetch as unknown as FetchFactory,
+    generatePatchOutput: ({ errorKind, error }) => {
+      return {
+        status: "patch",
+        errorKind,
+        message: error.message,
+      }
+    }
+  })
+
+  const result = await request.request({
+    baseUrl: "https://api.example.com",
+    path: "/users",
+    method: "get",
+    query: {
+      page: 1
+    },
+  })
+
+  expect(result).toEqual({
+    status: "patch",
+    errorKind: "unknown",
+    message: "boom",
+  })
+})

package/tests/unit/request/request/general.spec.ts

@@ -0,0 +1,160 @@
+import { expect, test } from "vitest"
+
+import { BaseFetch, GeneralRequest } from "#Source/request/index.ts"
+import type { BaseFetchOptions, FetchFactory, GeneralResource } from "#Source/request/index.ts"
+
+type ExampleGeneralResource = GeneralResource & {
+  baseUrl: "https://api.example.com"
+  path: "/users"
+  method: "get"
+  input: {
+    query: {
+      page: number
+    }
+    body?: undefined
+  }
+  successData: {
+    users: string[]
+  }
+  errorData: {
+    message: string
+  }
+}
+
+class TestGeneralResolvedFetch extends BaseFetch<
+  { query: ExampleGeneralResource["input"]["query"]; body: ExampleGeneralResource["input"]["body"] },
+  { type: "json"; data: { status: "success"; data: ExampleGeneralResource["successData"] } }
+> {
+  constructor() {
+    const options: BaseFetchOptions<
+      { query: ExampleGeneralResource["input"]["query"]; body: ExampleGeneralResource["input"]["body"] },
+      { type: "json"; data: { status: "success"; data: ExampleGeneralResource["successData"] } }
+    > = {
+      baseUrl: "https://api.example.com",
+      path: "/users",
+      method: "get",
+    }
+
+    super(options)
+  }
+
+  async getJson(): Promise<{ status: "success"; data: ExampleGeneralResource["successData"] }> {
+    return await Promise.resolve({
+      status: "success",
+      data: {
+        users: ["neo", "trinity"]
+      }
+    })
+  }
+
+  async getText(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+
+  async getBlob(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+
+  async getArrayBuffer(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+
+  async getStream(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+}
+
+class TestGeneralRejectingFetch extends BaseFetch<
+  { query: ExampleGeneralResource["input"]["query"]; body: ExampleGeneralResource["input"]["body"] },
+  { type: "json"; data: never }
+> {
+  constructor() {
+    const options: BaseFetchOptions<
+      { query: ExampleGeneralResource["input"]["query"]; body: ExampleGeneralResource["input"]["body"] },
+      { type: "json"; data: never }
+    > = {
+      baseUrl: "https://api.example.com",
+      path: "/users",
+      method: "get",
+    }
+
+    super(options)
+  }
+
+  async getJson(): Promise<never> {
+    await Promise.resolve()
+    throw new TypeError("fetch failed")
+  }
+
+  async getText(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+
+  async getBlob(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+
+  async getArrayBuffer(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+
+  async getStream(): Promise<never> {
+    await Promise.resolve()
+    throw new Error("Unused in GeneralRequest tests.")
+  }
+}
+
+test("GeneralRequest.request keeps success outputs and generates unknown patch outputs for failures", async () => {
+  let fetchFactoryCallCount: number = 0
+  const fetchFactory = (): TestGeneralResolvedFetch | TestGeneralRejectingFetch => {
+    fetchFactoryCallCount = fetchFactoryCallCount + 1
+
+    if (fetchFactoryCallCount === 1) {
+      return new TestGeneralResolvedFetch()
+    }
+
+    return new TestGeneralRejectingFetch()
+  }
+  const request = new GeneralRequest<ExampleGeneralResource>({
+    fetchFactory: fetchFactory as unknown as FetchFactory,
+  })
+
+  const successResult = await request.request({
+    baseUrl: "https://api.example.com",
+    path: "/users",
+    method: "get",
+    query: {
+      page: 1
+    },
+  })
+  const patchResult = await request.request({
+    baseUrl: "https://api.example.com",
+    path: "/users",
+    method: "get",
+    query: {
+      page: 2
+    },
+  })
+
+  expect(successResult).toEqual({
+    status: "success",
+    data: {
+      users: ["neo", "trinity"]
+    }
+  })
+  expect(patchResult).toEqual({
+    status: "unknown",
+    data: {
+      type: "error",
+      errorKind: "network",
+      error: new TypeError("fetch failed")
+    }
+  })
+})

package/tests/unit/result/controller.spec.ts

@@ -0,0 +1,82 @@
+import { expect, test } from "vitest"
+
+import type { Either } from "#Source/result/index.ts"
+import { Controller, controllerFromEitherType, Left, Right } from "#Source/result/index.ts"
+
+test("Controller.isLeft currently overflows through recursive static dispatch", () => {
+  expect(() => Controller.isLeft(new Left<string, number>("stop"))).toThrow(RangeError)
+})
+
+test("Controller.isRight currently overflows through recursive static dispatch", () => {
+  expect(() => Controller.isRight(new Right<string, number>(2))).toThrow(RangeError)
+})
+
+test("Controller.value exposes the same pending promise until the controller resolves", async () => {
+  const controller = new Controller<string, number>()
+  const firstValue = controller.value
+  const secondValue = controller.value
+
+  expect(secondValue).toBe(firstValue)
+
+  const returned = await controller.returnRight(2)
+  const settled = await firstValue
+
+  expect(settled).toBe(returned)
+  expect(settled.isRight()).toBe(true)
+  expect(settled.getRight()).toBe(2)
+})
+
+test("Controller.returnRight resolves the controller with a Right value", async () => {
+  const controller = new Controller<string, number>()
+
+  const returned = await controller.returnRight(2)
+  const settled = await controller.value
+
+  expect(returned).toBeInstanceOf(Right)
+  expect(returned).toBe(settled)
+  expect(returned.isRight()).toBe(true)
+  expect(returned.getRight()).toBe(2)
+})
+
+test("Controller.returnLeft resolves the controller with a Left value", async () => {
+  const controller = new Controller<string, number>()
+
+  const returned = await controller.returnLeft("stop")
+  const settled = await controller.value
+
+  expect(returned).toBeInstanceOf(Left)
+  expect(returned).toBe(settled)
+  expect(returned.isLeft()).toBe(true)
+  expect(returned.getLeft()).toBe("stop")
+})
+
+test("Controller.throw resolves the controller with a Left value and rejects with the same Left", async () => {
+  const controller = new Controller<string, number>()
+  let caught: unknown
+
+  try {
+    await controller.throw("stop")
+  } catch (error) {
+    caught = error
+  }
+
+  const settled = await controller.value
+
+  expect(caught).toBeInstanceOf(Left)
+  expect(caught).toBe(settled)
+  expect(settled.isLeft()).toBe(true)
+  expect(settled.getLeft()).toBe("stop")
+})
+
+test("controllerFromEitherType creates a controller that matches the Either shape", async () => {
+  const controller = controllerFromEitherType<Either<string, number>>()
+  const typedController: Controller<string, number> = controller
+
+  const returned = await typedController.returnRight(3)
+  const settled = await controller.value
+
+  expect(controller).toBeInstanceOf(Controller)
+  expect(returned).toBe(settled)
+  expect(returned.isRight()).toBe(true)
+  expect(returned.getRight()).toBe(3)
+})