soseki 0.0.1

package/tests/core/match-routes.test.ts

@@ -0,0 +1,178 @@
+import { test } from "vitest";
+import matchRoutes from "../../src/core/match-routes.js";
+import type { Route } from "../../src/core/route.types.js";
+
+test("指定したパス名がどのルートにもマッチしないとき、null を返す", ({ expect }) => {
+  // Arrange
+  const routes: Route[] = [
+    {
+      path: "/home",
+      pathPattern: /^\/home\/?$/i,
+      paramKeys: [],
+      index: true,
+      dataFuncs: [],
+      component: () => null,
+      children: [],
+    },
+  ];
+
+  // Act
+  const result = matchRoutes(routes, "/about");
+
+  // Assert
+  expect(result).toBeNull();
+});
+
+test("単一のルートにマッチしたとき、そのルートの属性と抽出されたパラメーターを返す", ({ expect }) => {
+  // Arrange
+  const routes: Route[] = [
+    {
+      path: "/user/:id",
+      pathPattern: /^\/user\/([^/]+?)\/?$/i,
+      paramKeys: ["id"],
+      index: true,
+      dataFuncs: [],
+      component: () => null,
+      children: [],
+    },
+  ];
+
+  // Act
+  const result = matchRoutes(routes, "/user/123");
+
+  // Assert
+  expect(result).toHaveLength(1);
+  expect(result![0].path).toBe("/user/:id");
+  expect(result![0].index).toBe(true);
+  expect(result![0].params).toStrictEqual({ id: "123" });
+  expect(result![0].urlPath).toBe("/user/123");
+});
+
+test("パスパターンよりネストされたルートにマッチしたとき、urlPath はパスパターンまでの情報のみを保持する", ({ expect }) => {
+  // Arrange
+  const routes: Route[] = [
+    {
+      path: "/user/:id",
+      pathPattern: /^\/user\/([^/]+?)(?:\/.*)?$/i,
+      paramKeys: ["id"],
+      index: false,
+      dataFuncs: [],
+      component: () => null,
+      children: [],
+    },
+  ];
+
+  // Act
+  const result = matchRoutes(routes, "/user/123/setting");
+
+  // Assert
+  expect(result).toHaveLength(1);
+  expect(result![0].path).toBe("/user/:id");
+  expect(result![0].index).toBe(false);
+  expect(result![0].params).toStrictEqual({ id: "123" });
+  expect(result![0].urlPath).toBe("/user/123");
+});
+
+test("ネストされたルートにマッチしたとき、子から親への階層構造を保持した配列を返す", ({ expect }) => {
+  // Arrange
+  const childRoute: Route = {
+    path: "/parent/child",
+    pathPattern: /^\/parent\/child\/?$/i,
+    paramKeys: [],
+    index: true,
+    dataFuncs: [],
+    component: () => "Child",
+    children: [],
+  };
+
+  const parentRoute: Route = {
+    path: "/parent",
+    pathPattern: /^\/parent(?:\/.*)?$/i,
+    paramKeys: [],
+    index: false,
+    dataFuncs: [],
+    component: () => "Parent",
+    children: [childRoute],
+  };
+
+  const routes = [parentRoute];
+
+  // Act
+  const result = matchRoutes(routes, "/parent/child");
+
+  // Assert
+  expect(result).toHaveLength(2);
+  expect(result![0].path).toBe("/parent/child");
+  expect(result![0].index).toBe(true);
+  expect(result![0].urlPath).toBe("/parent/child");
+  expect(result![1]!.path).toBe("/parent");
+  expect(result![1]!.path).toBe("/parent");
+  expect(result![1]!.urlPath).toBe("/parent");
+});
+
+test("複数のルート定義があるとき、最初にマッチしたルートの結果を返す", ({ expect }) => {
+  // Arrange
+  const routes: Route[] = [
+    {
+      path: "/a",
+      pathPattern: /^\/a\/?$/i,
+      paramKeys: [],
+      index: true,
+      dataFuncs: [],
+      component: () => "A",
+      children: [],
+    },
+    {
+      path: "/:id",
+      pathPattern: /^\/([^/]+?)\/?$/i,
+      paramKeys: ["id"],
+      index: true,
+      dataFuncs: [],
+      component: () => "Dynamic",
+      children: [],
+    },
+  ];
+
+  // Act
+  const result1 = matchRoutes(routes, "/a");
+  const result2 = matchRoutes(routes.toReversed(), "/a");
+
+  // Assert
+  expect(result1).toHaveLength(1);
+  expect(result1![0].path).toBe("/a");
+  expect(result2).toHaveLength(1);
+  expect(result2![0].path).toBe("/:id");
+});
+
+test("親ルートはマッチするが子ルートのいずれにもマッチしないとき、親ルートのみを含む配列を返す", ({ expect }) => {
+  // Arrange
+  const childRoute: Route = {
+    path: "/parent/child",
+    pathPattern: /^\/parent\/child\/?$/i,
+    paramKeys: [],
+    index: true,
+    dataFuncs: [],
+    component: () => "Child",
+    children: [],
+  };
+
+  const parentRoute: Route = {
+    path: "/parent",
+    pathPattern: /^\/parent(?:\/.*)?$/i,
+    paramKeys: [],
+    index: false,
+    dataFuncs: [],
+    component: () => "Parent",
+    children: [childRoute],
+  };
+
+  const routes = [parentRoute];
+
+  // Act
+  const result = matchRoutes(routes, "/parent/other");
+
+  // Assert
+  expect(result).toHaveLength(1);
+  expect(result![0].path).toBe("/parent");
+  expect(result![0].index).toBe(false);
+});

package/tests/core/redirect-response.test.ts

@@ -0,0 +1,36 @@
+import { test } from "vitest";
+import RedirectResponse from "../../src/core/redirect-response.js";
+
+test("パス名を渡してインスタンス化したとき、エンコードされたパス名が保持される", ({ expect }) => {
+  // Arrange
+  const rawPathname = "/テスト/データ";
+  const expectedEncodedPathname = "/%E3%83%86%E3%82%B9%E3%83%88/%E3%83%87%E3%83%BC%E3%82%BF";
+
+  // Act
+  const response = new RedirectResponse(rawPathname);
+
+  // Assert
+  expect(response.pathname).toBe(expectedEncodedPathname);
+});
+
+test("すでにエンコード済みのパス名を渡したとき、二重にエンコードされずそのままのパス名が保持される", ({ expect }) => {
+  // Arrange
+  const encodedPathname = "/%E3%83%86%E3%82%B9%E3%83%88";
+
+  // Act
+  const response = new RedirectResponse(encodedPathname);
+
+  // Assert
+  expect(response.pathname).toBe(encodedPathname);
+});
+
+test("空のパス名を渡したとき、ルートパスになる", ({ expect }) => {
+  // Arrange
+  const emptyPathname = "";
+
+  // Act
+  const response = new RedirectResponse(emptyPathname);
+
+  // Assert
+  expect(response.pathname).toBe("/");
+});

package/tests/core/route-request.test.ts

@@ -0,0 +1,93 @@
+import { describe, test } from "vitest";
+import type { ReadonlyFormData } from "../../src/core/readonly-form-data.types.js";
+import RouteRequest from "../../src/core/route-request.js";
+
+describe("インスタンス化", () => {
+  test("指定した HTTP メソッド、URL、AbortSignal、FormData で初期化した場合、それぞれのプロパティーに正しく保持される", ({ expect }) => {
+    // Arrange
+    const method = "POST";
+    const url = new URL("https://example.com/test?b=2&a=1");
+    const { signal } = new AbortController();
+    const formData = new FormData() as unknown as ReadonlyFormData;
+
+    // Act
+    const actual = new RouteRequest(method, url, signal, formData);
+
+    // Assert
+    expect(actual.method).toBe(method);
+    expect(actual.url).toBe(url);
+    expect(actual.signal).toBe(signal);
+    expect(actual.formData).toBe(formData);
+  });
+
+  test("FormData を省略して初期化した場合、formData プロパティーは null になる", ({ expect }) => {
+    // Arrange
+    const method = "GET";
+    const url = new URL("https://example.com/");
+    const { signal } = new AbortController();
+
+    // Act
+    const actual = new RouteRequest(method, url, signal);
+
+    // Assert
+    expect(actual.formData).toBeNull();
+  });
+});
+
+describe("toRequest", () => {
+  test("GET メソッドで Request オブジェクトを生成したとき、body が空で正しいメソッドと URL が設定される", ({ expect }) => {
+    // Arrange
+    const method = "GET";
+    const href = "https://example.com/api";
+    const url = new URL(href);
+    const { signal } = new AbortController();
+    const routeRequest = new RouteRequest(method, url, signal);
+
+    // Act
+    const actual = routeRequest.toRequest();
+
+    // Assert
+    expect(actual.method).toBe("GET");
+    expect(actual.url).toBe(href);
+    expect(actual.body).toBeNull();
+    expect(actual.signal).toEqual(signal);
+  });
+
+  test("POST メソッドと FormData を指定して Request オブジェクトを生成したとき、body に FormData が設定される", async ({ expect }) => {
+    // Arrange
+    const method = "POST";
+    const url = new URL("https://example.com/api");
+    const { signal } = new AbortController();
+    const formData = new FormData();
+    formData.append("key", "value");
+    const routeRequest = new RouteRequest(
+      method,
+      url,
+      signal,
+      formData as unknown as ReadonlyFormData,
+    );
+
+    // Act
+    const actual = routeRequest.toRequest();
+
+    // Assert
+    expect(actual.method).toBe("POST");
+    const actualFormData = await actual.formData();
+    expect(actualFormData.get("key")).toBe("value");
+  });
+
+  test("AbortSignal を渡して Request オブジェクトを生成したとき、signal が正しく伝播される", ({ expect }) => {
+    // Arrange
+    const controller = new AbortController();
+    const url = new URL("https://example.com/");
+    const routeRequest = new RouteRequest("GET", url, controller.signal);
+
+    // Act
+    const actual = routeRequest.toRequest();
+
+    // Assert
+    expect(actual.signal.aborted).toBe(false);
+    controller.abort();
+    expect(actual.signal.aborted).toBe(true);
+  });
+});

package/tests/core/start-actions.test.ts

@@ -0,0 +1,319 @@
+import { describe, test, vi } from "vitest";
+import actionIdRegistry from "../../src/core/_action-id-registry.js";
+import { IDataStore } from "../../src/core/data-store.types.js";
+import {
+  ActionConditionError,
+  ActionExecutionError,
+  MultipleRedirectError,
+} from "../../src/core/errors.js";
+import { HistoryEntryId } from "../../src/core/history-entry-id-schema.js";
+import RedirectResponse from "../../src/core/redirect-response.js";
+import { IAction } from "../../src/core/route.types.js";
+import startActions, { StartActionsParams } from "../../src/core/start-actions.js";
+
+describe("アクションの実行判定", () => {
+  test("アクションを持つルートが存在しないとき、undefined を返す", ({ expect }) => {
+    // Arrange
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [{
+            action: undefined,
+            loader: undefined,
+            shouldAction: () => true,
+            shouldReload: () => expect.unreachable(),
+          }],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+
+    // Assert
+    expect(wait).toBeUndefined();
+  });
+
+  test("shouldAction が true を返すとき、アクションが実行される", async ({ expect }) => {
+    // Arrange
+    const action = async () => "結果";
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [{
+            action,
+            loader: undefined,
+            shouldAction: () => true,
+            shouldReload: () => expect.unreachable(),
+          }],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+    const result = await wait!();
+
+    // Assert
+    expect(result.resultMap.get(action)).toBe("結果");
+  });
+
+  test("shouldAction が false を返すとき、アクションは実行されない", async ({ expect }) => {
+    // Arrange
+    const action = vi.fn();
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [{
+            action,
+            loader: undefined,
+            shouldAction: () => false,
+            shouldReload: () => expect.unreachable(),
+          }],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+    await wait?.();
+
+    // Assert
+    expect(action).not.toHaveBeenCalled();
+  });
+
+  test("フォームデータに _soseki_action_id が含まれるとき、ID が一致するアクションのみが実行される", async ({ expect }) => {
+    // Arrange
+    const action1 = async () => "result1";
+    const action2 = async () => "result2";
+    actionIdRegistry.set(action1);
+    const id2 = actionIdRegistry.set(action2);
+
+    const formData = new FormData();
+    formData.set("_soseki_action_id", id2);
+    const params = createParams({
+      formData: formData,
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [
+            {
+              action: action1,
+              loader: undefined,
+              shouldAction: ({ defaultShouldAction }) => defaultShouldAction,
+              shouldReload: () => expect.unreachable(),
+            },
+            {
+              action: action2,
+              loader: undefined,
+              shouldAction: ({ defaultShouldAction }) => defaultShouldAction,
+              shouldReload: () => expect.unreachable(),
+            },
+          ],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+    const result = await wait!();
+
+    // Assert
+    expect(result.resultMap.size).toBe(1);
+    expect(result.resultMap.has(action2)).toBe(true);
+    expect(result.resultMap.get(action2)).toBe("result2");
+  });
+});
+
+describe("アクションの実行結果", () => {
+  test("アクションが RedirectResponse を返したとき、結果の redirect フィールドにパスが設定される", async ({ expect }) => {
+    // Arrange
+    const action = async () => new RedirectResponse("/new-path");
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [{
+            action,
+            loader: undefined,
+            shouldAction: () => true,
+            shouldReload: () => expect.unreachable(),
+          }],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+    const result = await wait!();
+
+    // Assert
+    expect(result.redirect).toBe("/new-path");
+    expect(result.resultMap.get(action)).toBeUndefined();
+  });
+
+  test("複数のアクションが実行され、一方がリダイレクトを返したとき、正常に処理される", async ({ expect }) => {
+    // Arrange
+    const action1 = async () => "data";
+    const action2 = async () => new RedirectResponse("/path");
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [
+            {
+              action: action1,
+              loader: undefined,
+              shouldAction: () => true,
+              shouldReload: () => expect.unreachable(),
+            },
+            {
+              action: action2,
+              loader: undefined,
+              shouldAction: () => true,
+              shouldReload: () => expect.unreachable(),
+            },
+          ],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+    const result = await wait!();
+
+    // Assert
+    expect(result.redirect).toBe("/path");
+    expect(result.resultMap.get(action1)).toBe("data");
+  });
+});
+
+describe("異常系", () => {
+  test("shouldAction が非同期処理（Promise）を返したとき、ActionConditionError を含む ActionExecutionError が発生する", async ({ expect }) => {
+    // Arrange
+    const action = async () => "data";
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [{
+            action,
+            loader: undefined,
+            shouldAction: async () => true,
+            shouldReload: () => expect.unreachable(),
+          }],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+
+    // Assert
+    try {
+      await wait!();
+      expect.unreachable();
+    } catch (ex) {
+      expect(ex).toBeInstanceOf(ActionExecutionError);
+      expect((ex as ActionExecutionError).meta.errors).toStrictEqual([
+        {
+          action,
+          reason: expect.any(ActionConditionError),
+        },
+      ]);
+    }
+    // await expect(wait!()).rejects.toThrow(ActionConditionError);
+  });
+
+  test("アクションの実行中に例外が発生したとき、ActionExecutionError が発生する", async ({ expect }) => {
+    // Arrange
+    const error = new Error("失敗");
+    const action = async () => {
+      throw error;
+    };
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [{
+            action,
+            loader: undefined,
+            shouldAction: () => true,
+            shouldReload: () => expect.unreachable(),
+          }],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+
+    // Assert
+    await expect(wait!()).rejects.toThrow(ActionExecutionError);
+  });
+
+  test("複数のアクションが RedirectResponse を返したとき、MultipleRedirectError が発生する", async ({ expect }) => {
+    // Arrange
+    const action1 = async () => new RedirectResponse("/path1");
+    const action2 = async () => new RedirectResponse("/path2");
+    const params = createParams({
+      routes: [
+        {
+          params: {},
+          urlPath: "/",
+          dataFuncs: [
+            {
+              action: action1,
+              loader: undefined,
+              shouldAction: () => true,
+              shouldReload: () => expect.unreachable(),
+            },
+            {
+              action: action2,
+              loader: undefined,
+              shouldAction: () => true,
+              shouldReload: () => expect.unreachable(),
+            },
+          ],
+        },
+      ],
+    });
+
+    // Act
+    const wait = startActions(params);
+
+    // Assert
+    await expect(wait!()).rejects.toThrow(MultipleRedirectError);
+  });
+});
+
+/**
+ * テスト用の StartActionsParams を作成する。
+ */
+function createParams(overrides: Partial<StartActionsParams> = {}): StartActionsParams {
+  return {
+    routes: [],
+    entry: {
+      id: "67b82512-bd7e-414f-942f-df733bd53a6e" as HistoryEntryId,
+      url: new URL("http://localhost/"),
+    },
+    formData: new FormData(),
+    dataStore: {
+      get: () => undefined,
+      set: () => {},
+    } as unknown as IDataStore<IAction>,
+    signal: new AbortController().signal,
+    ...overrides,
+  };
+}