@cyclone-ui/registry-api 0.0.0-stage → 0.3.34

package/src/routes/components.ts

@@ -0,0 +1,175 @@
+/* -------------------------------------------------------------------
+
+                   🗲 Storm Software - Cyclone UI
+
+ This code was released as part of the Cyclone UI project. Cyclone UI
+ is maintained by Storm Software under the Apache-2.0 license, and is
+ free for commercial and private use. For more information, please visit
+ our licensing page at https://stormsoftware.com/licenses/projects/cyclone-ui.
+
+ Website:                  https://stormsoftware.com
+ Repository:               https://github.com/storm-software/cyclone-ui
+ Documentation:            https://docs.stormsoftware.com/projects/cyclone-ui
+ Contact:                  https://stormsoftware.com/contact
+
+ SPDX-License-Identifier:  Apache-2.0
+
+ ------------------------------------------------------------------- */
+
+import type { R2Object, R2ObjectBody } from "@cloudflare/workers-types";
+import { z } from "zod";
+import { createRouter, publicProcedure } from "../trpc";
+import type {
+  ComponentDetails,
+  ComponentMeta,
+  ComponentSummary,
+  RegistryStorage
+} from "../types";
+
+interface RegistryStorageFile {
+  name: string;
+  content: R2ObjectBody | null;
+  updatedOn: Date;
+}
+
+const COMPONENTS_PREFIX = "registry/components/";
+
+interface ComponentVersion {
+  componentName: string;
+  prefix: string;
+  metaObject: R2Object;
+}
+
+async function listAllObjects(
+  storage: RegistryStorage,
+  prefix: string
+): Promise<R2Object[]> {
+  const objects: R2Object[] = [];
+  let cursor: string | undefined;
+
+  do {
+    const result = await storage.list({ prefix, cursor });
+    objects.push(...result.objects);
+    cursor = result.truncated ? result.cursor : undefined;
+  } while (cursor);
+
+  return objects;
+}
+
+function getComponentVersion(storageObject: R2Object): ComponentVersion | null {
+  const relativeKey = storageObject.key.slice(COMPONENTS_PREFIX.length);
+  const segments = relativeKey.split("/").filter(Boolean);
+  if (segments.length < 2 || segments.at(-1) !== "meta.json") {
+    return null;
+  }
+
+  const componentName = segments[0]!;
+  const versionPath = segments.slice(1, -1).join("/");
+
+  return {
+    componentName,
+    prefix: `${COMPONENTS_PREFIX}${componentName}/${versionPath ? `${versionPath}/` : ""}`,
+    metaObject: storageObject
+  };
+}
+
+function getLatestVersions(objects: R2Object[]): ComponentVersion[] {
+  const versions = objects
+    .map(getComponentVersion)
+    .filter((value): value is ComponentVersion => Boolean(value));
+
+  return [...versions]
+    .sort(
+      (left, right) =>
+        right.metaObject.uploaded.getTime() - left.metaObject.uploaded.getTime()
+    )
+    .filter(
+      (version, index, all) =>
+        all.findIndex(
+          candidate => candidate.componentName === version.componentName
+        ) === index
+    );
+}
+
+export const componentsRouter = createRouter({
+  list: publicProcedure.query<ComponentSummary[]>(async ({ ctx }) => {
+    const latestVersions = getLatestVersions(
+      await listAllObjects(ctx.storage, COMPONENTS_PREFIX)
+    );
+
+    const components = await Promise.all(
+      latestVersions.map(async version => {
+        const content = await ctx.storage.get(version.metaObject.key);
+        if (!content) {
+          return null;
+        }
+
+        const meta = await content.json<ComponentMeta>();
+        return {
+          name: meta.name || version.componentName,
+          version: meta.version,
+          release: meta.release,
+          description: meta.description,
+          tags: meta.tags,
+          updatedOn: version.metaObject.uploaded
+        } as ComponentSummary;
+      })
+    );
+
+    return components.filter(Boolean) as ComponentSummary[];
+  }),
+  get: publicProcedure
+    .input(z.string())
+    .query<ComponentDetails>(async ({ input, ctx }) => {
+      const componentName = input.replace(/^@cyclone-ui\//, "");
+      const componentPrefix = `${COMPONENTS_PREFIX}${componentName}/`;
+      const storageObjects = await listAllObjects(ctx.storage, componentPrefix);
+      const latestVersion = getLatestVersions(storageObjects)[0];
+      if (!latestVersion) {
+        throw new Error(`Component \"${input}\" was not found`);
+      }
+
+      const storageFiles = (
+        await Promise.all(
+          storageObjects
+            .filter(storageObject =>
+              storageObject.key.startsWith(latestVersion.prefix)
+            )
+            .map(async (storageObject: R2Object) =>
+              ctx.storage
+                .get(storageObject.key)
+                .then((content: R2ObjectBody | null) => ({
+                  name: storageObject.key.slice(latestVersion.prefix.length),
+                  content,
+                  updatedOn: storageObject.uploaded
+                }))
+            )
+        )
+      ).filter(Boolean) as RegistryStorageFile[];
+
+      const metaFile = storageFiles.find(
+        (file: RegistryStorageFile) => file.name === "meta.json"
+      );
+      if (!metaFile || !metaFile.content) {
+        throw new Error("Metadata file not found");
+      }
+
+      const meta = await metaFile.content.json<ComponentMeta>();
+      const componentFiles = storageFiles.filter(
+        file => file.name !== "meta.json" && file.content
+      );
+      const componentContent = await Promise.all(
+        componentFiles
+          .filter(file => file.name !== "meta.json" && file.content)
+          .map(async file => Promise.resolve(file.content!.text()))
+      );
+
+      return {
+        ...meta,
+        files: componentFiles.map((file, index) => ({
+          ...file,
+          content: componentContent[index]!
+        }))
+      };
+    })
+});

package/src/trpc.ts

@@ -0,0 +1,31 @@
+/* -------------------------------------------------------------------
+
+                   🗲 Storm Software - Cyclone UI
+
+ This code was released as part of the Cyclone UI project. Cyclone UI
+ is maintained by Storm Software under the Apache-2.0 license, and is
+ free for commercial and private use. For more information, please visit
+ our licensing page at https://stormsoftware.com/licenses/projects/cyclone-ui.
+
+ Website:                  https://stormsoftware.com
+ Repository:               https://github.com/storm-software/cyclone-ui
+ Documentation:            https://docs.stormsoftware.com/projects/cyclone-ui
+ Contact:                  https://stormsoftware.com/contact
+
+ SPDX-License-Identifier:  Apache-2.0
+
+ ------------------------------------------------------------------- */
+
+import type { TRPCRootObject } from "@trpc/server";
+import { initTRPC } from "@trpc/server";
+import type { Context } from "./context";
+
+// eslint-disable-next-line ts/no-empty-object-type
+export const t: TRPCRootObject<Context, object, {}> = initTRPC
+  .context<Context>()
+  .create();
+
+export const publicProcedure: typeof t.procedure = t.procedure;
+export const protectedProcedure: typeof t.procedure = t.procedure;
+
+export const createRouter: typeof t.router = t.router;

package/src/types.ts

@@ -0,0 +1,70 @@
+/* -------------------------------------------------------------------
+
+                   🗲 Storm Software - Cyclone UI
+
+ This code was released as part of the Cyclone UI project. Cyclone UI
+ is maintained by Storm Software under the Apache-2.0 license, and is
+ free for commercial and private use. For more information, please visit
+ our licensing page at https://stormsoftware.com/licenses/projects/cyclone-ui.
+
+ Website:                  https://stormsoftware.com
+ Repository:               https://github.com/storm-software/cyclone-ui
+ Documentation:            https://docs.stormsoftware.com/projects/cyclone-ui
+ Contact:                  https://stormsoftware.com/contact
+
+ SPDX-License-Identifier:  Apache-2.0
+
+ ------------------------------------------------------------------- */
+
+import type { R2ObjectBody, R2Objects } from "@cloudflare/workers-types";
+
+export type ComponentPlatform = "web" | "mobile" | "all";
+
+export const ComponentPlatform = {
+  WEB: "web" as ComponentPlatform,
+  MOBILE: "mobile" as ComponentPlatform,
+  ALL: "all" as ComponentPlatform
+};
+
+interface ComponentHeader {
+  name: string;
+  version?: string;
+  release: string;
+  tags: string[];
+  description: string;
+}
+
+export interface ComponentSummary extends ComponentHeader {
+  updatedOn: Date;
+}
+
+export interface ComponentMeta extends ComponentHeader {
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  internalDependencies: string[];
+}
+
+export interface ComponentFile {
+  name: string;
+  content: string;
+  checksum?: string;
+  updatedOn: Date;
+}
+
+export interface ComponentDetails extends ComponentMeta {
+  files: ComponentFile[];
+}
+
+export const HttpHeaders = {
+  Version: "x-cyclone-version",
+  Checksum: "x-cyclone-checksum"
+};
+
+export interface Env {
+  STORAGE_BUCKET: RegistryStorage;
+}
+
+export interface RegistryStorage {
+  list(options: { prefix: string; cursor?: string }): Promise<R2Objects>;
+  get(key: string): Promise<R2ObjectBody | null>;
+}

package/test/routes/components.spec.ts

@@ -0,0 +1,96 @@
+import type { R2Object, R2ObjectBody } from "@cloudflare/workers-types";
+import { describe, expect, it, vi } from "vitest";
+import type { Context } from "../../src/context";
+import { router } from "../../src/router";
+import type { ComponentMeta, RegistryStorage } from "../../src/types";
+
+function object(key: string, uploaded: string): R2Object {
+  return { key, uploaded: new Date(uploaded) } as R2Object;
+}
+
+function body(value: ComponentMeta | string): R2ObjectBody {
+  return {
+    json: vi.fn(async () => value),
+    text: vi.fn(async () =>
+      typeof value === "string" ? value : JSON.stringify(value)
+    )
+  } as unknown as R2ObjectBody;
+}
+
+function meta(version: string): ComponentMeta {
+  return {
+    name: "button",
+    version,
+    release: "latest",
+    description: "A button.",
+    tags: ["form"],
+    dependencies: {},
+    devDependencies: {},
+    internalDependencies: []
+  };
+}
+
+function context(
+  objects: R2Object[],
+  contents: Record<string, R2ObjectBody>
+): Context {
+  return {
+    version: undefined,
+    storage: {
+      list: vi.fn(async () => ({
+        objects,
+        truncated: false,
+        delimitedPrefixes: []
+      })),
+      get: vi.fn(async (key: string) => contents[key] ?? null)
+    } as unknown as RegistryStorage
+  } as Context;
+}
+
+describe("components router", () => {
+  it("lists only the newest uploaded version of each component", async () => {
+    const oldMeta = "registry/components/button/1.0.0/meta.json";
+    const newMeta = "registry/components/button/2.0.0/meta.json";
+    const caller = router.createCaller(
+      context(
+        [
+          object(oldMeta, "2026-01-01T00:00:00Z"),
+          object(newMeta, "2026-02-01T00:00:00Z")
+        ],
+        { [oldMeta]: body(meta("1.0.0")), [newMeta]: body(meta("2.0.0")) }
+      )
+    );
+
+    await expect(caller.components.list()).resolves.toMatchObject([
+      { name: "button", version: "2.0.0" }
+    ]);
+  });
+
+  it("returns files only from the newest component version", async () => {
+    const oldMeta = "registry/components/button/1.0.0/meta.json";
+    const oldFile = "registry/components/button/1.0.0/index.ts";
+    const newMeta = "registry/components/button/2.0.0/meta.json";
+    const newFile = "registry/components/button/2.0.0/index.ts";
+    const caller = router.createCaller(
+      context(
+        [
+          object(oldMeta, "2026-01-01T00:00:00Z"),
+          object(oldFile, "2026-01-01T00:00:00Z"),
+          object(newMeta, "2026-02-01T00:00:00Z"),
+          object(newFile, "2026-02-01T00:00:00Z")
+        ],
+        {
+          [oldMeta]: body(meta("1.0.0")),
+          [oldFile]: body("old"),
+          [newMeta]: body(meta("2.0.0")),
+          [newFile]: body("new")
+        }
+      )
+    );
+
+    await expect(caller.components.get("button")).resolves.toMatchObject({
+      version: "2.0.0",
+      files: [{ name: "index.ts", content: "new" }]
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "../../dist/out-tsc/packages/registry-api/tsconfig.tsbuildinfo",
+    "types": ["@cloudflare/workers-types"],
+    "strict": true,
+    "declaration": true,
+    "outDir": "../../dist/out-tsc/packages/registry-api",
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["src/**/*", "powerlines.config.ts", "powerlines.d.ts"],
+  "exclude": ["vitest.config.mts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "node",
+      "vitest",
+      "@cloudflare/workers-types"
+    ],
+    "outDir": "../../dist/out-tsc"
+  },
+  "include": ["vitest.config.mts", "src/**/*.ts", "src/**/*.d.ts"],
+  "exclude": []
+}

package/vitest.config.mts

@@ -0,0 +1,24 @@
+import { nxViteTsPaths } from "@nx/vite/plugins/nx-tsconfig-paths.plugin";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig(() => ({
+  root: import.meta.dirname,
+  cacheDir: "../../node_modules/.vite/packages/registry-api",
+  plugins: [nxViteTsPaths()],
+  test: {
+    name: "registry-api",
+    watch: false,
+    globals: true,
+    environment: "node",
+    include: [
+      "src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
+      "test/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
+      "tests/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"
+    ],
+    reporters: ["default"],
+    coverage: {
+      reportsDirectory: "../../coverage/packages/registry-api",
+      provider: "v8" as const
+    }
+  }
+}));