파티셔닝시 CanonicalOperation 을 blob object 로 리턴하도록 수정

packages/patchlogr-core/src/partition/__tests__/partitionByMethod.test.ts

@@ -87,4 +87,80 @@ describe("partitionByMethod", () => {
  expect(postMethodNode?.children).toHaveLength(1);
  expect(postMethodNode?.children?.[0]?.key).toBe("POST /auth/login");
  });
+
+ test("hashObjects를 리턴한다", () => {
+ const spec: CanonicalSpec = {
+ operations: {
+ "GET /user": {
+ key: "GET /user",
+ doc: { tags: ["user"] },
+ method: "GET",
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ },
+ "POST /user": {
+ key: "POST /user",
+ doc: { tags: ["user"] },
+ method: "POST",
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ },
+ },
+ };
+
+ const result = partitionByMethod(spec);
+
+ expect(result.hashObjects).toBeDefined();
+ expect(result.hashObjects).toHaveLength(2);
+ });
+
+ test("리프노드에는 value가 포함되지 않는다", () => {
+ const spec: CanonicalSpec = {
+ operations: {
+ "GET /user": {
+ key: "GET /user",
+ doc: { tags: ["user"] },
+ method: "GET",
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ },
+ },
+ };
+
+ const result = partitionByMethod(spec);
+ const leafNode = result.root.children?.[0]?.children?.[0];
+
+ expect(leafNode?.type).toBe("leaf");
+ expect(leafNode?.hash).toBeDefined();
+ expect(leafNode?.value).toBeUndefined();
+ });
+
+ test("hashObjects에 리프노드에 대한 CanonicalOperation 이 매핑된다", () => {
+ const operation = {
+ key: "GET /user" as const,
+ doc: { tags: ["user"] },
+ method: "GET" as const,
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ };
+
+ const spec: CanonicalSpec = {
+ operations: {
+ "GET /user": operation,
+ },
+ };
+
+ const result = partitionByMethod(spec);
+ const leafNode = result.root.children?.[0]?.children?.[0];
+ const hashObject = result.hashObjects.find(
+ (ho) => ho.hash === leafNode?.hash,
+ );
+
+ expect(hashObject).toBeDefined();
+ expect(hashObject?.data).toEqual(operation);
+ });
 });

packages/patchlogr-core/src/partition/__tests__/partitionByTag.test.ts

@@ -112,4 +112,80 @@ describe("partitionByTag", () => {
  expect(defaultTagNode?.children).toHaveLength(1);
  expect(defaultTagNode?.children?.[0]?.key).toBe("GET /user");
  });
+
+ test("hashObjects를 리턴한다", () => {
+ const spec: CanonicalSpec = {
+ operations: {
+ "GET /user": {
+ key: "GET /user",
+ doc: { tags: ["user"] },
+ method: "GET",
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ },
+ "POST /user": {
+ key: "POST /user",
+ doc: { tags: ["user"] },
+ method: "POST",
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ },
+ },
+ };
+
+ const result = partitionByTag(spec);
+
+ expect(result.hashObjects).toBeDefined();
+ expect(result.hashObjects).toHaveLength(2);
+ });
+
+ test("리프노드에는 value가 포함되지 않는다", () => {
+ const spec: CanonicalSpec = {
+ operations: {
+ "GET /user": {
+ key: "GET /user",
+ doc: { tags: ["user"] },
+ method: "GET",
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ },
+ },
+ };
+
+ const result = partitionByTag(spec);
+ const leafNode = result.root.children?.[0]?.children?.[0];
+
+ expect(leafNode?.type).toBe("leaf");
+ expect(leafNode?.hash).toBeDefined();
+ expect(leafNode?.value).toBeUndefined();
+ });
+
+ test("hashObjects에 리프노드에 대한 CanonicalOperation 이 매핑된다", () => {
+ const operation = {
+ key: "GET /user" as const,
+ doc: { tags: ["user"] },
+ method: "GET" as const,
+ path: "/user",
+ request: { params: [] },
+ responses: {},
+ };
+
+ const spec: CanonicalSpec = {
+ operations: {
+ "GET /user": operation,
+ },
+ };
+
+ const result = partitionByTag(spec);
+ const leafNode = result.root.children?.[0]?.children?.[0];
+ const hashObject = result.hashObjects.find(
+ (ho) => ho.hash === leafNode?.hash,
+ );
+
+ expect(hashObject).toBeDefined();
+ expect(hashObject?.data).toEqual(operation);
+ });
 });

packages/patchlogr-core/src/partition/index.ts

@@ -1,4 +1,5 @@
-export type { Hash, HashNode, PartitionedSpec } from "./partition";
+export type { Hash, HashNode } from "./types/hashNode";
+export type { PartitionedSpec } from "./types/partitionedSpec";
 
 export { partitionByMethod } from "./partitionByMethod";
 export { partitionByTag } from "./partitionByTag";
@@ -8,4 +9,4 @@ export {
  createLeafNode,
  createHashedLeaf,
  createHashedNode,
-} from "./createNode";
+} from "./utils/createNode";

packages/patchlogr-core/src/partition/partitionByMethod.ts

@@ -3,7 +3,10 @@ import type {
  HTTPMethod,
  CanonicalOperation,
 } from "@patchlogr/types";
-import type { PartitionedSpec, HashNode } from "./partition";
+
+import type { HashNode } from "./types/hashNode";
+import type { PartitionedSpec } from "./types/partitionedSpec";
+import type { HashObject } from "./types/hashObject";
 
 import { createSHA256Hash } from "../utils/createHash";
 import stableStringify from "fast-json-stable-stringify";
@@ -15,6 +18,7 @@ export function partitionByMethod(
  HTTPMethod,
  Array<{ key: string; operation: CanonicalOperation }>
  >();
+ const hashObjects: HashObject<CanonicalOperation>[] = [];
 
  Object.entries(spec.operations).forEach(([key, operation]) => {
  if (!methodGroups.has(operation.method)) {
@@ -30,12 +34,15 @@ export function partitionByMethod(
 
  methodGroups.forEach((operations, method) => {
  const operationLeaves: HashNode<string, CanonicalOperation>[] =
- operations.map(({ key, operation }) => ({
- type: "leaf",
- key,
- hash: createSHA256Hash(stableStringify(operation)),
- value: operation,
- }));
+ operations.map(({ key, operation }) => {
+ const hash = createSHA256Hash(stableStringify(operation));
+ hashObjects.push({ hash, data: operation });
+ return {
+ type: "leaf" as const,
+ key,
+ hash,
+ };
+ });
 
  const methodHash = createSHA256Hash(
  stableStringify(operationLeaves.map((leaf) => leaf.hash)),
@@ -66,5 +73,6 @@ export function partitionByMethod(
  ...spec.info,
  ...spec.security,
  },
+ hashObjects,
  };
 }

packages/patchlogr-core/src/partition/partitionByTag.ts

@@ -1,9 +1,8 @@
-import type {
- CanonicalSpec,
- CanonicalOperation,
- OperationKey,
-} from "@patchlogr/types";
-import type { PartitionedSpec, HashNode } from "./partition";
+import type { CanonicalSpec, CanonicalOperation } from "@patchlogr/types";
+
+import type { PartitionedSpec } from "./types/partitionedSpec";
+import type { HashNode } from "./types/hashNode";
+import type { HashObject } from "./types/hashObject";
 
 import { createSHA256Hash } from "../utils/createHash";
 import stableStringify from "fast-json-stable-stringify";
@@ -17,6 +16,7 @@ export function partitionByTag(
  string,
  Array<{ key: string; operation: CanonicalOperation }>
  >();
+ const hashObjects: HashObject<CanonicalOperation>[] = [];
 
  Object.entries(spec.operations).forEach(([key, operation]) => {
  const tag = operation.doc?.tags?.[0] || DEFAULT_TAG;
@@ -25,7 +25,7 @@ export function partitionByTag(
  tagGroups.set(tag, []);
  }
  tagGroups.get(tag)?.push({
- key: key as OperationKey,
+ key: key,
  operation,
  });
  });
@@ -34,12 +34,15 @@ export function partitionByTag(
 
  tagGroups.forEach((operations, tag) => {
  const operationLeaves: HashNode<string, CanonicalOperation>[] =
- operations.map(({ key, operation }) => ({
- type: "leaf",
- key,
- hash: createSHA256Hash(stableStringify(operation)),
- value: operation,
- }));
+ operations.map(({ key, operation }) => {
+ const hash = createSHA256Hash(stableStringify(operation));
+ hashObjects.push({ hash, data: operation });
+ return {
+ type: "leaf",
+ key,
+ hash,
+ };
+ });
 
  const tagHash = createSHA256Hash(
  stableStringify(operationLeaves.map((leaf) => leaf.hash)),
@@ -70,5 +73,6 @@ export function partitionByTag(
  ...spec.info,
  ...spec.security,
  },
+ hashObjects,
  };
 }

packages/patchlogr-core/src/partition/partition.ts → packages/patchlogr-core/src/partition/types/hashNode.ts

@@ -7,8 +7,3 @@ export type HashNode<K = string, V = unknown> = {
  children?: HashNode<K, V>[];
  value?: V;
 };
-
-export type PartitionedSpec<K = string, V = unknown> = {
- root: HashNode<K, V>;
- metadata: Record<string, unknown>;
-};

packages/patchlogr-core/src/partition/types/hashObject.ts

@@ -0,0 +1,4 @@
+export type HashObject<T> = {
+ hash: string;
+ data: T;
+};

packages/patchlogr-core/src/partition/types/partitionedSpec.ts

@@ -0,0 +1,8 @@
+import type { HashNode } from "./hashNode";
+import type { HashObject } from "./hashObject";
+
+export type PartitionedSpec<K = string, V = unknown> = {
+ root: HashNode<K, V>;
+ metadata: Record<string, unknown>;
+ hashObjects: HashObject<V>[];
+};

packages/patchlogr-core/src/partition/createNode.ts → packages/patchlogr-core/src/partition/utils/createNode.ts

@@ -1,5 +1,5 @@
-import type { HashNode } from "./partition";
-import { createSHA256Hash } from "../utils/createHash";
+import type { HashNode } from "../types/hashNode";
+import { createSHA256Hash } from "../../utils/createHash";
 import stableStringify from "fast-json-stable-stringify";
 
 export function createNode<K, V>(