baysecms-client 1.0.0

package/README.md

@@ -0,0 +1,90 @@
+# BayseCMS Client SDK
+
+Small TypeScript client for BayseCMS APIs with a focus on frontend DX.
+
+## Create Client
+
+```ts
+import { createBayseCMSClient } from "@your-scope/client";
+
+const cms = createBayseCMSClient({
+  baseUrl: "http://localhost:4000",
+  accessToken: "<jwt-access-token>"
+});
+```
+
+You can also provide:
+
+- `getAccessToken: async () => string` for token refresh flows
+- `apiKey`, `tenantId`, `workspaceId` for server-to-server usage
+
+## Frontend-ready v2 Delivery APIs
+
+### List content
+
+```ts
+const response = await cms.getContent({
+  schema: "rooms",
+  limit: 20,
+  status: "published"
+});
+
+console.log(response.items);
+console.log(response.pageInfo);
+```
+
+### Get by slug
+
+```ts
+const room = await cms.getContentBySlug("rooms", "deluxe-room");
+console.log(room.data.title);
+```
+
+## Response shape (v2)
+
+Each item is normalized for frontend consumption:
+
+```ts
+type DeliveryItem = {
+  id: string;
+  slug: string | null;
+  createdAt: string | null;
+  updatedAt: string | null;
+  data: Record<string, unknown>;
+};
+```
+
+Notes:
+
+- `data` uses field keys as defined in schema
+- image fields are normalized to `{ url, alt }` (or arrays of this shape)
+- array/object fields are consistently normalized (`[]`, `{}`)
+
+## Legacy/admin APIs still available
+
+The client also supports existing endpoints:
+
+- `listSchemas()`
+- `upsertContent(input)`
+- `listDocuments(collection)`
+- `getDocument(collection, documentId)`
+- `deleteDocument(collection, documentId)`
+- `listPublished(collection)`
+
+## Error handling
+
+SDK throws `Error` with extra metadata:
+
+- `error.status` (HTTP code)
+- `error.body` (parsed response body when available)
+
+Example:
+
+```ts
+try {
+  await cms.getContent({ schema: "rooms" });
+} catch (error) {
+  const e = error as Error & { status?: number; body?: unknown };
+  console.error(e.status, e.body);
+}
+```

package/dist/client.d.ts

@@ -0,0 +1,45 @@
+import type { ContentDocument, DeliveryBySlugResponse, DeliveryListQuery, DeliveryListResponse, ListSchemasResponse, OkResponse, UpsertContentInput } from "./types.js";
+export type BayseCMSClientOptions = {
+    /** API origin, e.g. https://api.example.com */
+    baseUrl: string;
+    /** Bearer JWT (Cognito access token or HS256 dev token). */
+    getAccessToken?: () => string | Promise<string>;
+    /** Static token if you do not use async refresh. */
+    accessToken?: string;
+    /** Server-to-server or delivery-only auth */
+    apiKey?: string;
+    tenantId?: string;
+    workspaceId?: string;
+};
+export declare class BayseCMSClient {
+    private readonly options;
+    constructor(options: BayseCMSClientOptions);
+    private headers;
+    private request;
+    /** Raw GET request for generated helpers and advanced consumers. */
+    get<T>(path: string): Promise<T>;
+    /** Raw POST request for generated helpers and advanced consumers. */
+    post<T>(path: string, body?: unknown): Promise<T>;
+    /** List schema versions for the current tenant/workspace. */
+    listSchemas(): Promise<ListSchemasResponse>;
+    /** Single schema version (for building UIs / validation). */
+    getSchema(schemaId: string, version: number): Promise<unknown>;
+    /** Create or update a document (requires editor+ JWT). */
+    upsertContent(input: UpsertContentInput): Promise<OkResponse>;
+    /** All documents in a collection (draft + published). */
+    listDocuments(collection: string): Promise<ContentDocument[]>;
+    getDocument(collection: string, documentId: string): Promise<ContentDocument>;
+    deleteDocument(collection: string, documentId: string): Promise<OkResponse>;
+    /** Published documents for a collection (viewer JWT or API key). */
+    listPublished(collection: string): Promise<ContentDocument[]>;
+    /**
+     * Frontend-ready normalized content list (v2 API).
+     * Returns stable shape: { id, slug, createdAt, updatedAt, data }.
+     */
+    getContent(query: DeliveryListQuery): Promise<DeliveryListResponse>;
+    /**
+     * Frontend-ready single item fetch by slug (v2 API).
+     */
+    getContentBySlug(schema: string, slug: string): Promise<DeliveryBySlugResponse["item"]>;
+}
+export declare function createBayseCMSClient(options: BayseCMSClientOptions): BayseCMSClient;

package/dist/client.js

@@ -0,0 +1,118 @@
+const normalizeBase = (url) => url.replace(/\/$/, "");
+export class BayseCMSClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async headers() {
+        const h = {
+            "content-type": "application/json",
+            accept: "application/json"
+        };
+        let token = this.options.accessToken;
+        if (this.options.getAccessToken) {
+            token = await this.options.getAccessToken();
+        }
+        if (token) {
+            h.authorization = `Bearer ${token}`;
+        }
+        if (this.options.apiKey) {
+            h["x-api-key"] = this.options.apiKey;
+        }
+        else {
+            if (this.options.tenantId) {
+                h["x-tenant-id"] = this.options.tenantId;
+            }
+            if (this.options.workspaceId) {
+                h["x-workspace-id"] = this.options.workspaceId;
+            }
+        }
+        return h;
+    }
+    async request(method, path, body) {
+        const url = `${normalizeBase(this.options.baseUrl)}${path.startsWith("/") ? path : `/${path}`}`;
+        const res = await fetch(url, {
+            method,
+            headers: await this.headers(),
+            body: body !== undefined && method !== "GET" && method !== "DELETE" ? JSON.stringify(body) : undefined
+        });
+        const text = await res.text();
+        let data = text;
+        try {
+            data = text ? JSON.parse(text) : undefined;
+        }
+        catch {
+            data = text;
+        }
+        if (!res.ok) {
+            const err = new Error(`BayseCMS ${res.status}: ${typeof data === "string" ? data : JSON.stringify(data)}`);
+            err.status = res.status;
+            err.body = data;
+            throw err;
+        }
+        return data;
+    }
+    /** Raw GET request for generated helpers and advanced consumers. */
+    async get(path) {
+        return this.request("GET", path);
+    }
+    /** Raw POST request for generated helpers and advanced consumers. */
+    async post(path, body) {
+        return this.request("POST", path, body);
+    }
+    /** List schema versions for the current tenant/workspace. */
+    async listSchemas() {
+        return this.request("GET", "/schemas");
+    }
+    /** Single schema version (for building UIs / validation). */
+    async getSchema(schemaId, version) {
+        return this.request("GET", `/schemas/${encodeURIComponent(schemaId)}/${encodeURIComponent(String(version))}`);
+    }
+    /** Create or update a document (requires editor+ JWT). */
+    async upsertContent(input) {
+        return this.request("POST", "/content/upsert", input);
+    }
+    /** All documents in a collection (draft + published). */
+    async listDocuments(collection) {
+        const path = `/content/documents/${encodeURIComponent(collection)}`;
+        const res = await this.request("GET", path);
+        return res.items ?? [];
+    }
+    async getDocument(collection, documentId) {
+        return this.request("GET", `/content/documents/${encodeURIComponent(collection)}/${encodeURIComponent(documentId)}`);
+    }
+    async deleteDocument(collection, documentId) {
+        return this.request("DELETE", `/content/documents/${encodeURIComponent(collection)}/${encodeURIComponent(documentId)}`);
+    }
+    /** Published documents for a collection (viewer JWT or API key). */
+    async listPublished(collection) {
+        const path = `/delivery/${encodeURIComponent(collection)}`;
+        const res = await this.request("GET", path);
+        return res.items ?? [];
+    }
+    /**
+     * Frontend-ready normalized content list (v2 API).
+     * Returns stable shape: { id, slug, createdAt, updatedAt, data }.
+     */
+    async getContent(query) {
+        const params = new URLSearchParams();
+        params.set("schema", query.schema);
+        if (query.limit !== undefined)
+            params.set("limit", String(query.limit));
+        if (query.cursor)
+            params.set("cursor", query.cursor);
+        if (query.status)
+            params.set("status", query.status);
+        return this.request("GET", `/v2/content?${params.toString()}`);
+    }
+    /**
+     * Frontend-ready single item fetch by slug (v2 API).
+     */
+    async getContentBySlug(schema, slug) {
+        const res = await this.request("GET", `/v2/content/${encodeURIComponent(schema)}/${encodeURIComponent(slug)}`);
+        return res.item;
+    }
+}
+export function createBayseCMSClient(options) {
+    return new BayseCMSClient(options);
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { BayseCMSClient, createBayseCMSClient } from "./client.js";
+export type { BayseCMSClientOptions } from "./client.js";
+export type { ContentDocument, DeliveryBySlugResponse, DeliveryImage, DeliveryItem, DeliveryListQuery, DeliveryListResponse, ListDocumentsResponse, ListPublishedResponse, ListSchemasResponse, OkResponse, UpsertContentInput } from "./types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { BayseCMSClient, createBayseCMSClient } from "./client.js";

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Types aligned with BayseCMS HTTP API (delivery + content upsert).
+ */
+export type UpsertContentInput = {
+    documentId: string;
+    collection: string;
+    schemaId: string;
+    schemaVersion: number;
+    status: "draft" | "published";
+    data: Record<string, unknown>;
+};
+export type ContentDocument = UpsertContentInput & {
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type DeliveryImage = {
+    url: string;
+    alt?: string;
+};
+export type DeliveryItem = {
+    id: string;
+    slug: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    data: Record<string, unknown>;
+};
+export type DeliveryListQuery = {
+    schema: string;
+    limit?: number;
+    cursor?: string;
+    status?: "published" | "draft" | "all";
+};
+export type DeliveryPageInfo = {
+    nextCursor: string | null;
+    hasMore: boolean;
+};
+export type DeliveryListResponse = {
+    items: DeliveryItem[];
+    pageInfo: DeliveryPageInfo;
+};
+export type DeliveryBySlugResponse = {
+    item: DeliveryItem;
+};
+export type ListSchemasResponse = {
+    items: unknown[];
+};
+export type ListPublishedResponse = {
+    items: ContentDocument[];
+};
+export type OkResponse = {
+    ok: boolean;
+};
+export type ListDocumentsResponse = {
+    items: ContentDocument[];
+};

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types aligned with BayseCMS HTTP API (delivery + content upsert).
+ */
+export {};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "baysecms-client",
+  "version": "1.0.0",
+  "description": "TypeScript client SDK for BayseCMS APIs",
+  "license": "UNLICENSED",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}