@planet-matrix/mobius-model 0.6.0 → 0.10.1

package/tests/unit/form/inputor-controller/helper.spec.ts

@@ -0,0 +1,67 @@
+import { expect, test } from "vitest"
+
+import {
+  BooleanInputorController,
+  FileInputorController,
+  FormInputorController,
+  MultiSelectInputorController,
+  NumberInputorController,
+  SelectInputorController,
+  TextInputorController,
+  boolean as createBooleanInputor,
+  file as createFileInputor,
+  form as createFormInputor,
+  multiSelect as createMultiSelectInputor,
+  number as createNumberInputor,
+  select as createSelectInputor,
+  text as createTextInputor,
+} from "#Source/form/index.ts"
+
+test("boolean creates a BooleanInputorController", () => {
+  expect(createBooleanInputor({ value: false })).toBeInstanceOf(BooleanInputorController)
+})
+
+test("number creates a NumberInputorController", () => {
+  expect(createNumberInputor({ value: 1 })).toBeInstanceOf(NumberInputorController)
+})
+
+test("text creates a TextInputorController", () => {
+  expect(createTextInputor({ value: "alpha" })).toBeInstanceOf(TextInputorController)
+})
+
+test("file creates a FileInputorController", () => {
+  expect(createFileInputor({ value: undefined })).toBeInstanceOf(FileInputorController)
+})
+
+test("select creates a SelectInputorController", () => {
+  expect(createSelectInputor({ value: [] })).toBeInstanceOf(SelectInputorController)
+})
+
+test("multiSelect creates a MultiSelectInputorController", () => {
+  expect(createMultiSelectInputor({ value: [] })).toBeInstanceOf(MultiSelectInputorController)
+})
+
+test("form creates a FormInputorController", () => {
+  const nameController = createTextInputor({ value: "alpha" })
+  const ageController = createNumberInputor({ value: 1 })
+
+  expect(createFormInputor({
+    value: {
+      name: "alpha",
+      age: 1,
+    },
+    items: {
+      name: nameController,
+      age: ageController,
+    },
+    encodeValue: (schemaDict) => {
+      return {
+        name: schemaDict.name.value,
+        age: schemaDict.age.value,
+      }
+    },
+    decodeValue: (value) => {
+      return value
+    },
+  })).toBeInstanceOf(FormInputorController)
+})

package/tests/unit/form/inputor-controller/multi-select.spec.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "vitest"
+
+import { MultiSelectInputorController } from "#Source/form/index.ts"
+
+test("MultiSelectInputorController.select toggles options while respecting disabled items and maxSelectCount", async () => {
+  const controller = new MultiSelectInputorController<string>({
+    id: "multi-select-id",
+    value: [
+      { name: "a", label: "A", value: "a", isSelected: true },
+      { name: "b", label: "B", value: "b", isSelected: false },
+      { name: "c", label: "C", value: "c", isSelected: false, isDisabled: true },
+    ],
+    maxSelectCount: 1,
+  })
+
+  await controller.waitForReady()
+  await controller.select("b")
+
+  expect((await controller.getSchema()).value).toEqual([
+    { name: "a", label: "A", value: "a", isSelected: true },
+    { name: "b", label: "B", value: "b", isSelected: false },
+    { name: "c", label: "C", value: "c", isSelected: false, isDisabled: true },
+  ])
+
+  await controller.select("a")
+  await controller.select("b")
+  await controller.select("c")
+
+  expect((await controller.getSchema()).value).toEqual([
+    { name: "a", label: "A", value: "a", isSelected: false },
+    { name: "b", label: "B", value: "b", isSelected: true },
+    { name: "c", label: "C", value: "c", isSelected: false, isDisabled: true },
+  ])
+})

package/tests/unit/form/inputor-controller/number.spec.ts

@@ -0,0 +1,36 @@
+import { expect, test } from "vitest"
+
+import {
+  NUMBER_INPUTOR_TYPE_NAME,
+  NumberInputorController,
+} from "#Source/form/index.ts"
+
+test("NumberInputorController.getSchema exposes constraints and updateValue clamps with step rounding", async () => {
+  const controller = new NumberInputorController({
+    id: "number-id",
+    value: 2,
+    min: 0,
+    max: 10,
+    step: 3,
+  })
+
+  await controller.waitForReady()
+  await controller.updateValue(11)
+
+  expect(await controller.getSchema()).toEqual({
+    inputorTypeName: NUMBER_INPUTOR_TYPE_NAME,
+    id: "number-id",
+    name: `number-number-id`,
+    placeholder: "",
+    value: 9,
+    isVoid: false,
+    isFocused: false,
+    isTouched: false,
+    isDirty: true,
+    isDisabled: false,
+    isDebugMode: false,
+    min: 0,
+    max: 10,
+    step: 3,
+  })
+})

package/tests/unit/form/inputor-controller/select.spec.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "vitest"
+
+import { SelectInputorController } from "#Source/form/index.ts"
+
+test("SelectInputorController.select keeps disabled selected options sticky and supports unselect", async () => {
+  const stickyController = new SelectInputorController<string>({
+    id: "select-sticky-id",
+    value: [
+      { name: "a", label: "A", value: "a", isSelected: false },
+      { name: "b", label: "B", value: "b", isSelected: true, isDisabled: true },
+      { name: "c", label: "C", value: "c", isSelected: false },
+    ],
+  })
+
+  await stickyController.waitForReady()
+  await stickyController.select("a")
+
+  expect((await stickyController.getSchema()).value).toEqual([
+    { name: "a", label: "A", value: "a", isSelected: false },
+    { name: "b", label: "B", value: "b", isSelected: true, isDisabled: true },
+    { name: "c", label: "C", value: "c", isSelected: false },
+  ])
+
+  const unselectController = new SelectInputorController<string>({
+    id: "select-unselect-id",
+    value: [
+      { name: "a", label: "A", value: "a", isSelected: false },
+      { name: "b", label: "B", value: "b", isSelected: false },
+    ],
+    enableUnselect: true,
+  })
+
+  await unselectController.waitForReady()
+  await unselectController.select("a")
+  await unselectController.select("a")
+
+  expect((await unselectController.getSchema()).value).toEqual([
+    { name: "a", label: "A", value: "a", isSelected: false },
+    { name: "b", label: "B", value: "b", isSelected: false },
+  ])
+
+  await unselectController.updateIsDisabled(true)
+  await unselectController.select("b")
+
+  expect((await unselectController.getSchema()).value).toEqual([
+    { name: "a", label: "A", value: "a", isSelected: false },
+    { name: "b", label: "B", value: "b", isSelected: false },
+  ])
+})

package/tests/unit/form/inputor-controller/text.spec.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "vitest"
+
+import {
+  TEXT_INPUTOR_TYPE_NAME,
+  TextInputorController,
+} from "#Source/form/index.ts"
+
+test("TextInputorController.getSchema exposes length constraints and updateValue truncates by maxLength", async () => {
+  const controller = new TextInputorController({
+    id: "text-id",
+    value: "hello",
+    minLength: 2,
+    maxLength: 4,
+  })
+
+  await controller.waitForReady()
+  await controller.updateValue("planet")
+
+  expect(await controller.getSchema()).toEqual({
+    inputorTypeName: TEXT_INPUTOR_TYPE_NAME,
+    id: "text-id",
+    name: `text-text-id`,
+    placeholder: "",
+    value: "plan",
+    isVoid: false,
+    isFocused: false,
+    isTouched: false,
+    isDirty: true,
+    isDisabled: false,
+    isDebugMode: false,
+    minLength: 2,
+    maxLength: 4,
+  })
+})

package/tests/unit/http/api/api-core-host.spec.ts

@@ -0,0 +1,207 @@
+import { expect, test, vi } from "vitest"
+
+import type {
+  ApiCoreHandler,
+  ApiCoreHeaders,
+  ApiCoreRequestFiles,
+  ApiCoreRequestFormData,
+  ApiCoreStream,
+  ApiHostStartResult,
+} from "#Source/http/index.ts"
+import { ApiCore, ApiHost } from "#Source/http/index.ts"
+
+interface TestApiCoreOptions {
+  url: string
+  method: string
+  headers?: ApiCoreHeaders | undefined
+  bodyText?: string | undefined
+  formData?: ApiCoreRequestFormData | undefined
+}
+
+class TestApiCore extends ApiCore {
+  readonly jsonPayloads: unknown[] = []
+  readonly textPayloads: unknown[] = []
+  errorCallCount = 0
+
+  private readonly url: string
+  private readonly method: string
+  private readonly headers: ApiCoreHeaders
+  private readonly bodyText: string
+  private readonly formData: ApiCoreRequestFormData
+
+  constructor(options: TestApiCoreOptions) {
+    super()
+
+    this.url = options.url
+    this.method = options.method
+    this.headers = options.headers ?? {}
+    this.bodyText = options.bodyText ?? ""
+    this.formData = options.formData ?? []
+  }
+
+  async getRequestHeaders(): Promise<ApiCoreHeaders> {
+    return await Promise.resolve(this.headers)
+  }
+
+  async getRequestMethod(): Promise<string> {
+    return await Promise.resolve(this.method)
+  }
+
+  getRequestUrl(): string {
+    return this.url
+  }
+
+  async getRequestBodyText(): Promise<string> {
+    return await Promise.resolve(this.bodyText)
+  }
+
+  async getRequestBodyFormData(): Promise<ApiCoreRequestFormData> {
+    return await Promise.resolve(this.formData)
+  }
+
+  async text(data: unknown): Promise<void> {
+    this.textPayloads.push(data)
+    await Promise.resolve()
+  }
+
+  async json(data: unknown): Promise<void> {
+    this.jsonPayloads.push(data)
+    await Promise.resolve()
+  }
+
+  async stream(): Promise<ApiCoreStream> {
+    return await Promise.resolve({
+      write: vi.fn(async () => {
+        await Promise.resolve()
+      }),
+      end: vi.fn(async () => {
+        await Promise.resolve()
+      }),
+    })
+  }
+
+  async error(): Promise<void> {
+    this.errorCallCount = this.errorCallCount + 1
+    await Promise.resolve()
+  }
+}
+
+class TestApiHost extends ApiHost<{ id: string }> {
+  apiCoreHandler: ApiCoreHandler | undefined
+  startCallCount = 0
+  closeCallCount = 0
+
+  constructor() {
+    super({ port: 0 })
+  }
+
+  attachApiCoreHandler(apiCoreHandler: ApiCoreHandler): void {
+    this.apiCoreHandler = apiCoreHandler
+  }
+
+  async start(): Promise<ApiHostStartResult> {
+    this.startCallCount = this.startCallCount + 1
+    this.server = { id: "server-1" }
+
+    return await Promise.resolve({
+      urlList: ["http://127.0.0.1:0"],
+    })
+  }
+
+  async close(): Promise<void> {
+    this.closeCallCount = this.closeCallCount + 1
+    this.server = undefined
+    await Promise.resolve()
+  }
+}
+
+test("ApiCore.getRequestHeader returns lowercase header values", async () => {
+  const apiCore = new TestApiCore({
+    url: "http://127.0.0.1/users?page=2",
+    method: "GET",
+    headers: {
+      "x-trace-id": ["trace-1"],
+    },
+  })
+
+  await expect(apiCore.getRequestHeader("X-Trace-Id")).resolves.toEqual(["trace-1"])
+})
+
+test("ApiCore.getRequestPath extracts the pathname from the request URL", async () => {
+  const apiCore = new TestApiCore({
+    url: "http://127.0.0.1/users?page=2",
+    method: "GET",
+  })
+
+  await expect(apiCore.getRequestPath()).resolves.toBe("/users")
+})
+
+test("ApiCore.getRequestSearch extracts the search string from the request URL", async () => {
+  const apiCore = new TestApiCore({
+    url: "http://127.0.0.1/users?page=2",
+    method: "GET",
+  })
+
+  await expect(apiCore.getRequestSearch()).resolves.toBe("?page=2")
+})
+
+test("ApiCore.getRequestBodyJson parses JSON bodies and treats blank bodies as empty objects", async () => {
+  const jsonApiCore = new TestApiCore({
+    url: "http://127.0.0.1/users",
+    method: "POST",
+    bodyText: '{"name":"Mobius"}',
+  })
+  const emptyApiCore = new TestApiCore({
+    url: "http://127.0.0.1/users",
+    method: "POST",
+    bodyText: "   ",
+  })
+
+  await expect(jsonApiCore.getRequestBodyJson()).resolves.toEqual({
+    name: "Mobius",
+  })
+  await expect(emptyApiCore.getRequestBodyJson()).resolves.toEqual({})
+})
+
+test("ApiCore.getRequestFiles returns only file entries from form data", async () => {
+  const file = new File(["avatar"], "avatar.txt", { type: "text/plain" })
+  const apiCore = new TestApiCore({
+    url: "http://127.0.0.1/upload",
+    method: "POST",
+    formData: [
+      { name: "name", value: "Mobius" },
+      { name: "avatar", value: file },
+    ],
+  })
+
+  const files = await apiCore.getRequestFiles()
+
+  expect(files).toEqual<ApiCoreRequestFiles>([
+    {
+      name: "avatar",
+      value: file,
+    },
+  ])
+})
+
+test("ApiHost.safeGetServer throws before start and returns the running server after start", async () => {
+  const apiHost = new TestApiHost()
+
+  expect(() => apiHost.safeGetServer()).toThrow("Server is not running.")
+
+  await apiHost.start()
+
+  expect(apiHost.safeGetServer()).toEqual({ id: "server-1" })
+})
+
+test("ApiHost.isRunning reflects whether a server is attached", async () => {
+  const apiHost = new TestApiHost()
+
+  expect(apiHost.isRunning()).toBe(false)
+
+  await apiHost.start()
+  expect(apiHost.isRunning()).toBe(true)
+
+  await apiHost.close()
+  expect(apiHost.isRunning()).toBe(false)
+})

package/tests/unit/http/api/api-schema.spec.ts

@@ -0,0 +1,120 @@
+import { expect, test } from "vitest"
+
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { createApiSchema } from "#Source/http/index.ts"
+
+const isRecord = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === "object" && value !== null
+}
+
+const createSchema = <Output>(
+  validate: (value: unknown) => StandardSchemaV1.Result<Output>,
+): StandardSchemaV1<unknown, Output> => {
+  return {
+    "~standard": {
+      version: 1 as const,
+      vendor: "mobius-http-test",
+      validate,
+    },
+  }
+}
+
+const inputQuerySchema = createSchema<{ page: string }>((value) => {
+  if (isRecord(value) && typeof value["page"] === "string") {
+    return {
+      value: {
+        page: value["page"],
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "page is required" }],
+  }
+})
+
+const inputBodySchema = createSchema<{ name: string }>((value) => {
+  if (isRecord(value) && typeof value["name"] === "string") {
+    return {
+      value: {
+        name: value["name"],
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "name is required" }],
+  }
+})
+
+const outputSuccessSchema = createSchema<{ status: "success" }>((value) => {
+  if (typeof value === "object" && value !== null && (value as { status?: unknown }).status === "success") {
+    return {
+      value: {
+        status: "success",
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "status must be success" }],
+  }
+})
+
+const outputErrorSchema = createSchema<{ status: "error" }>((value) => {
+  if (typeof value === "object" && value !== null && (value as { status?: unknown }).status === "error") {
+    return {
+      value: {
+        status: "error",
+      },
+    }
+  }
+
+  return {
+    issues: [{ message: "status must be error" }],
+  }
+})
+
+const apiSchema = createApiSchema({
+  path: "/users",
+  method: "post",
+  inputQuerySchema,
+  inputBodySchema,
+  outputSuccessSchema,
+  outputErrorSchema,
+})
+
+test("ApiSchema.getApiSchemaOptions returns the configured schema options", () => {
+  expect(apiSchema.getApiSchemaOptions()).toEqual({
+    path: "/users",
+    method: "post",
+    inputQuerySchema,
+    inputBodySchema,
+    outputSuccessSchema,
+    outputErrorSchema,
+  })
+})
+
+test("ApiSchema.getPath returns the configured path", () => {
+  expect(apiSchema.getPath()).toBe("/users")
+})
+
+test("ApiSchema.getMethod returns the configured method", () => {
+  expect(apiSchema.getMethod()).toBe("post")
+})
+
+test("ApiSchema.getInputQuerySchema returns the configured query schema", () => {
+  expect(apiSchema.getInputQuerySchema()).toBe(inputQuerySchema)
+})
+
+test("ApiSchema.getInputBodySchema returns the configured body schema", () => {
+  expect(apiSchema.getInputBodySchema()).toBe(inputBodySchema)
+})
+
+test("ApiSchema.getOutputSuccessSchema returns the configured success schema", () => {
+  expect(apiSchema.getOutputSuccessSchema()).toBe(outputSuccessSchema)
+})
+
+test("ApiSchema.getOutputErrorSchema returns the configured error schema", () => {
+  expect(apiSchema.getOutputErrorSchema()).toBe(outputErrorSchema)
+})