@inglorious/ssx 1.1.0 → 1.1.1

package/src/store/store.test.js

@@ -0,0 +1,56 @@
+import path from "node:path"
+
+import { describe, expect, it } from "vitest"
+
+import { generateStore } from "."
+
+const ROOT_DIR = path.join(__dirname, "..", "__fixtures__")
+
+describe("generateStore", () => {
+  it("should generate the proper types and entities from a static page", async () => {
+    const page = {
+      filePath: path.join(ROOT_DIR, "pages", "index.js"),
+    }
+
+    const store = await generateStore([page], { rootDir: ROOT_DIR })
+
+    expect(store.getType("index").render).toBeDefined()
+    expect(store.getState()).toMatchSnapshot()
+  })
+
+  it("should generate the proper types and entities from a page with an entity", async () => {
+    const page = {
+      filePath: path.join(ROOT_DIR, "pages", "about.js"),
+    }
+
+    const store = await generateStore([page], { rootDir: ROOT_DIR })
+
+    expect(store.getType("about").render).toBeDefined()
+    expect(store.getState()).toMatchSnapshot()
+  })
+
+  it("should generate the proper types and entities from a page that has metadata", async () => {
+    const page = {
+      filePath: path.join(ROOT_DIR, "pages", "blog.js"),
+    }
+
+    const store = await generateStore([page], { rootDir: ROOT_DIR })
+
+    expect(store.getType("blog").render).toBeDefined()
+    expect(store.getState()).toMatchSnapshot()
+  })
+
+  it("should handle missing entities.js gracefully", async () => {
+    const page = {
+      filePath: path.join(ROOT_DIR, "pages", "index.js"),
+    }
+
+    // Point to a directory that doesn't contain entities.js
+    const store = await generateStore([page], {
+      rootDir: path.join(ROOT_DIR, "pages"),
+    })
+
+    // Should initialize with empty entities (or at least not the ones from fixtures)
+    expect(store.getState()).not.toHaveProperty("about")
+  })
+})

package/src/{module.js → utils/module.js}

@@ -1,3 +1,11 @@
+/**
+ * Extracts the name of the exported entity from a page module.
+ * It looks for an export that is an object containing a `render` function.
+ *
+ * @param {Object} pageModule - The module object imported from a page file.
+ * @returns {string} The name of the export that represents the entity.
+ * @throws {Error} If no valid entity export is found.
+ */
 export function getModuleName(pageModule) {
   const name = Object.keys(pageModule).find((key) => {
     const value = pageModule[key]

package/src/utils/module.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest"
+
+import { getModuleName } from "./module"
+
+describe("getModuleName", () => {
+  it("should get the name when it's the only export", () => {
+    const module = {
+      about: {
+        render: () => {},
+      },
+    }
+
+    expect(getModuleName(module)).toBe("about")
+  })
+
+  it("should get the name when there's other exports", () => {
+    const module = {
+      about: {
+        render: () => {},
+      },
+      title: "About",
+      meta: {
+        description: "About page",
+      },
+      scripts: ["/script.js"],
+      styles: ["/style.css"],
+    }
+
+    expect(getModuleName(module)).toBe("about")
+  })
+
+  it("should get the name when the exports are functions", () => {
+    const module = {
+      about: {
+        render: () => {},
+      },
+      title: () => "About",
+      meta: () => ({
+        description: "About page",
+      }),
+      scripts: ["/script.js"],
+      styles: ["/style.css"],
+    }
+
+    expect(getModuleName(module)).toBe("about")
+  })
+
+  it("should throw an error when no entity with render method is found", () => {
+    const module = {
+      title: "Just title",
+      meta: {},
+    }
+    expect(() => getModuleName(module)).toThrow(
+      /Page module must export an entity/,
+    )
+  })
+
+  it("should throw an error for empty module", () => {
+    const module = {}
+    expect(() => getModuleName(module)).toThrow(
+      /Page module must export an entity/,
+    )
+  })
+})

package/src/utils/page-options.js

@@ -0,0 +1,17 @@
+/**
+ * Creates a helper function to retrieve page options (metadata) with fallback defaults.
+ * Handles both static metadata objects and dynamic metadata functions.
+ *
+ * @param {Object} store - The application store instance.
+ * @param {Object} module - The imported page module.
+ * @param {Object} entity - The entity associated with the page.
+ * @returns {function(string, Object): any} A function that retrieves a specific option by name.
+ */
+export function createGetPageOption(store, module, entity) {
+  let { metadata = {} } = module
+  if (typeof metadata === "function") {
+    metadata = metadata(entity, store._api)
+  }
+
+  return (name, defaults) => metadata[name] ?? defaults[name]
+}

package/src/utils/page-options.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from "vitest"
+
+import { createGetPageOption } from "./page-options"
+
+describe("createGetPageOption", () => {
+  const mockStore = { _api: { someApi: true } }
+  const mockEntity = { id: 1, title: "Entity Title" }
+
+  it("should retrieve value from static metadata object", () => {
+    const module = {
+      metadata: {
+        title: "Static Title",
+        priority: 0.8,
+      },
+    }
+
+    const getOption = createGetPageOption(mockStore, module, mockEntity)
+    const defaults = { title: "Default", priority: 0.5, author: "Me" }
+
+    expect(getOption("title", defaults)).toBe("Static Title")
+    expect(getOption("priority", defaults)).toBe(0.8)
+    expect(getOption("author", defaults)).toBe("Me")
+  })
+
+  it("should retrieve value from dynamic metadata function", () => {
+    const module = {
+      metadata: vi.fn((entity, api) => ({
+        title: `Dynamic ${entity.title}`,
+        apiAvailable: !!api,
+      })),
+    }
+
+    const getOption = createGetPageOption(mockStore, module, mockEntity)
+    const defaults = { title: "Default", apiAvailable: false }
+
+    expect(module.metadata).toHaveBeenCalledWith(mockEntity, mockStore._api)
+    expect(getOption("title", defaults)).toBe("Dynamic Entity Title")
+    expect(getOption("apiAvailable", defaults)).toBe(true)
+  })
+
+  it("should use defaults when metadata is missing", () => {
+    const module = {} // No metadata export
+
+    const getOption = createGetPageOption(mockStore, module, mockEntity)
+    const defaults = { title: "Default Title" }
+
+    expect(getOption("title", defaults)).toBe("Default Title")
+  })
+
+  it("should use defaults when specific key is missing in metadata", () => {
+    const module = { metadata: { other: "value" } }
+    const getOption = createGetPageOption(mockStore, module, mockEntity)
+    const defaults = { title: "Default Title" }
+
+    expect(getOption("title", defaults)).toBe("Default Title")
+  })
+})

package/src/module.test.js

@@ -1,45 +0,0 @@
-import { expect, it } from "vitest"
-
-import { getModuleName } from "./module"
-
-it("should get the name when it's the only export", () => {
-  const module = {
-    about: {
-      render: () => {},
-    },
-  }
-
-  expect(getModuleName(module)).toBe("about")
-})
-
-it("should get the name when there's other exports", () => {
-  const module = {
-    about: {
-      render: () => {},
-    },
-    title: "About",
-    meta: {
-      description: "About page",
-    },
-    scripts: ["/script.js"],
-    styles: ["/style.css"],
-  }
-
-  expect(getModuleName(module)).toBe("about")
-})
-
-it("should get the name when the exports are functions", () => {
-  const module = {
-    about: {
-      render: () => {},
-    },
-    title: () => "About",
-    meta: () => ({
-      description: "About page",
-    }),
-    scripts: ["/script.js"],
-    styles: ["/style.css"],
-  }
-
-  expect(getModuleName(module)).toBe("about")
-})

package/src/page-options.js

@@ -1,8 +0,0 @@
-export function createGetPageOption(store, module, entity) {
-  let { metadata = {} } = module
-  if (typeof metadata === "function") {
-    metadata = metadata(entity, store._api)
-  }
-
-  return (name, defaults) => metadata[name] ?? defaults[name]
-}

package/src/store.test.js

@@ -1,40 +0,0 @@
-import path from "node:path"
-
-import { expect, it } from "vitest"
-
-import { generateStore } from "./store"
-
-const ROOT_DIR = path.join(__dirname, "__fixtures__")
-
-it("should generate the proper types and entities from a static page", async () => {
-  const page = {
-    filePath: path.join(ROOT_DIR, "pages", "index.js"),
-  }
-
-  const store = await generateStore([page], { rootDir: ROOT_DIR })
-
-  expect(store.getType("index").render).toBeDefined()
-  expect(store.getState()).toMatchSnapshot()
-})
-
-it("should generate the proper types and entities from a page with an entity", async () => {
-  const page = {
-    filePath: path.join(ROOT_DIR, "pages", "about.js"),
-  }
-
-  const store = await generateStore([page], { rootDir: ROOT_DIR })
-
-  expect(store.getType("about").render).toBeDefined()
-  expect(store.getState()).toMatchSnapshot()
-})
-
-it("should generate the proper types and entities from a page that has metadata", async () => {
-  const page = {
-    filePath: path.join(ROOT_DIR, "pages", "blog.js"),
-  }
-
-  const store = await generateStore([page], { rootDir: ROOT_DIR })
-
-  expect(store.getType("blog").render).toBeDefined()
-  expect(store.getState()).toMatchSnapshot()
-})