@isardsat/editorial-client 6.6.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @isardsat/editorial-client
+
+## 6.6.1
+
+### Patch Changes
+
+- a09a4ba: Initial JS client version
+- Updated dependencies [a09a4ba]
+  - @isardsat/editorial-common@6.6.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Lobelia Earth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+# @isardsat/editorial-client
+
+A JavaScript/TypeScript client for the Editorial CMS API.
+
+## Installation
+
+```bash
+npm install @isardsat/editorial-client
+# or
+pnpm add @isardsat/editorial-client
+```
+
+## Usage
+
+TBD

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import type { ClientOptions, EditorialClientInterface } from "./types.js";
+export declare function createEditorialClient(baseURL: string, options?: ClientOptions): EditorialClientInterface;

package/dist/client.js

@@ -0,0 +1,115 @@
+import { EditorialError, EditorialNetworkError, EditorialNotFoundError, EditorialValidationError, } from "./errors.js";
+export function createEditorialClient(baseURL, options = {}) {
+    const apiBaseURL = new URL("/api/v1/", baseURL);
+    const defaultLocale = options.defaultLocale || "en";
+    const fetchFn = options.fetch || globalThis.fetch;
+    const defaultHeaders = {
+        "Content-Type": "application/json",
+        ...options.headers,
+    };
+    const timeout = options.timeout || 30000;
+    async function request(endpoint, requestOptions = {}) {
+        const url = new URL(endpoint, apiBaseURL);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetchFn(url.toString(), {
+                ...requestOptions,
+                headers: {
+                    ...defaultHeaders,
+                    ...requestOptions.headers,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorMessage = await response
+                    .text()
+                    .catch(() => response.statusText);
+                if (response.status === 404) {
+                    throw new EditorialNotFoundError(errorMessage);
+                }
+                if (response.status === 400) {
+                    throw new EditorialValidationError(errorMessage);
+                }
+                throw new EditorialError(errorMessage || `HTTP ${response.status} ${response.statusText}`, response.status, response.statusText);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof EditorialError) {
+                throw error;
+            }
+            if (error instanceof DOMException && error.name === "AbortError") {
+                throw new EditorialNetworkError("Request timeout");
+            }
+            throw new EditorialNetworkError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`, error instanceof Error ? error : undefined);
+        }
+    }
+    function buildQueryParams(options = {}) {
+        const params = new URLSearchParams();
+        if (options.locale && options.locale !== defaultLocale) {
+            params.append("lang", options.locale);
+        }
+        if (options.preview) {
+            params.append("preview", "true");
+        }
+        return params;
+    }
+    return {
+        async getSchema() {
+            return request("schema");
+        },
+        async getConfig() {
+            return request("config");
+        },
+        async getContent(options = {}) {
+            const params = buildQueryParams(options);
+            const endpoint = params.toString() ? `data?${params}` : "data";
+            return request(endpoint);
+        },
+        async getContentByType(type, options = {}) {
+            const params = buildQueryParams(options);
+            const endpoint = params.toString()
+                ? `data/${encodeURIComponent(type)}?${params}`
+                : `data/${encodeURIComponent(type)}`;
+            const result = await request(endpoint);
+            return Object.values(result);
+        },
+        async getContentIds(type, options = {}) {
+            const params = new URLSearchParams();
+            if (options.preview) {
+                params.append("preview", "true");
+            }
+            const endpoint = params.toString()
+                ? `data/${encodeURIComponent(type)}/ids?${params}`
+                : `data/${encodeURIComponent(type)}/ids`;
+            return request(endpoint);
+        },
+        async getContentById(type, id, options = {}) {
+            const params = buildQueryParams(options);
+            const endpoint = params.toString()
+                ? `data/${encodeURIComponent(type)}/${encodeURIComponent(id)}?${params}`
+                : `data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`;
+            return request(endpoint);
+        },
+        async createContent(type, id, data) {
+            return request(`data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`, {
+                method: "PUT",
+                body: JSON.stringify(data),
+            });
+        },
+        async updateContent(type, id, data) {
+            return request(`data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify(data),
+            });
+        },
+        async deleteContent(type, id) {
+            return request(`data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`, {
+                method: "DELETE",
+            });
+        },
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class EditorialError extends Error {
+    readonly status?: number | undefined;
+    readonly statusText?: string | undefined;
+    constructor(message: string, status?: number | undefined, statusText?: string | undefined);
+}
+export declare class EditorialNetworkError extends EditorialError {
+    readonly cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+export declare class EditorialNotFoundError extends EditorialError {
+    constructor(resource: string, id?: string);
+}
+export declare class EditorialValidationError extends EditorialError {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,33 @@
+export class EditorialError extends Error {
+    status;
+    statusText;
+    constructor(message, status, statusText) {
+        super(message);
+        this.status = status;
+        this.statusText = statusText;
+        this.name = "EditorialError";
+    }
+}
+export class EditorialNetworkError extends EditorialError {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "EditorialNetworkError";
+    }
+}
+export class EditorialNotFoundError extends EditorialError {
+    constructor(resource, id) {
+        const message = id
+            ? `${resource} with id '${id}' not found`
+            : `${resource} not found`;
+        super(message, 404, "Not Found");
+        this.name = "EditorialNotFoundError";
+    }
+}
+export class EditorialValidationError extends EditorialError {
+    constructor(message) {
+        super(message, 400, "Bad Request");
+        this.name = "EditorialValidationError";
+    }
+}

package/dist/helpers.d.ts

@@ -0,0 +1,70 @@
+import type { EditorialDataItem, EditorialDataType, EditorialData } from "@isardsat/editorial-common";
+import type { EditorialClientInterface } from "./types.js";
+export declare function createEditorialHelpers(client: EditorialClientInterface): {
+    getContentIds({ type, locale, preview, }: {
+        type: string;
+        locale?: string;
+        preview?: boolean;
+    }): Promise<string[]>;
+    getContent<T = import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        isDraft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>({ type, id, locale, preview, }: {
+        type: string;
+        id: string;
+        locale?: string;
+        preview?: boolean;
+    }): Promise<T>;
+    getContentByType<T = Record<string, import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        isDraft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>({ type, locale, preview, }: {
+        type: string;
+        locale?: string;
+        preview?: boolean;
+    }): Promise<T>;
+    getAllContent<T = Record<string, Record<string, import("zod").objectOutputType<{
+        id: import("zod").ZodString;
+        isDraft: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        createdAt: import("zod").ZodDefault<import("zod").ZodString>;
+        updatedAt: import("zod").ZodDefault<import("zod").ZodString>;
+    }, import("zod").ZodTypeAny, "passthrough">>>>({ locale, preview, }?: {
+        locale?: string;
+        preview?: boolean;
+    }): Promise<T>;
+    getSchema(): Promise<Record<string, {
+        displayName: string;
+        fields: Record<string, import("zod").objectOutputType<{
+            type: import("zod").ZodEnum<["string", "boolean", "date", "datetime", "markdown", "number", "color", "select", "url"]>;
+            displayName: import("zod").ZodString;
+            displayExtra: import("zod").ZodOptional<import("zod").ZodString>;
+            placeholder: import("zod").ZodOptional<import("zod").ZodString>;
+            isRequired: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            showInSummary: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        singleton?: boolean | undefined;
+    }>>;
+    getConfig(): Promise<{
+        name: string;
+        publicUrl: string;
+        publicDir: string;
+        publicDeletedDir: string;
+        filesUrl: string;
+        largeFilesUrl: string;
+        previewUrl?: string | undefined;
+        silent?: boolean | undefined;
+        firebase?: {
+            apiKey: string;
+            authDomain: string;
+            databaseURL: string;
+            projectId: string;
+            storageBucket: string;
+            messagingSenderId: string;
+            dbUsersPath: string;
+        } | undefined;
+    }>;
+};

package/dist/helpers.js

@@ -0,0 +1,51 @@
+const DEFAULT_LANG = "en";
+export function createEditorialHelpers(client) {
+    return {
+        async getContentIds({ type, locale, preview, }) {
+            const options = {};
+            if (locale && locale !== DEFAULT_LANG) {
+                options.locale = locale;
+            }
+            if (preview) {
+                options.preview = true;
+            }
+            return client.getContentIds(type, options);
+        },
+        async getContent({ type, id, locale, preview, }) {
+            const options = {};
+            if (locale && locale !== DEFAULT_LANG) {
+                options.locale = locale;
+            }
+            if (preview) {
+                options.preview = true;
+            }
+            return client.getContentById(type, id, options);
+        },
+        async getContentByType({ type, locale, preview, }) {
+            const options = {};
+            if (locale && locale !== DEFAULT_LANG) {
+                options.locale = locale;
+            }
+            if (preview) {
+                options.preview = true;
+            }
+            return client.getContentByType(type, options);
+        },
+        async getAllContent({ locale, preview, } = {}) {
+            const options = {};
+            if (locale && locale !== DEFAULT_LANG) {
+                options.locale = locale;
+            }
+            if (preview) {
+                options.preview = true;
+            }
+            return client.getContent(options);
+        },
+        async getSchema() {
+            return client.getSchema();
+        },
+        async getConfig() {
+            return client.getConfig();
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createEditorialClient } from "./client.js";
+export { EditorialError, EditorialNetworkError, EditorialNotFoundError, EditorialValidationError, } from "./errors.js";
+export type { ClientOptions, EditorialClientInterface, EditorialConfig, EditorialData, EditorialDataItem, EditorialDataType, EditorialSchema, GetContentOptions, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createEditorialClient } from "./client.js";
+export { EditorialError, EditorialNetworkError, EditorialNotFoundError, EditorialValidationError, } from "./errors.js";

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import type { EditorialConfig, EditorialData, EditorialDataItem, EditorialDataType, EditorialSchema } from "@isardsat/editorial-common";
+export interface ClientOptions {
+    fetch?: typeof globalThis.fetch;
+    headers?: Record<string, string>;
+    defaultLocale?: string;
+    timeout?: number;
+}
+export interface GetContentOptions {
+    locale?: string;
+    preview?: boolean;
+}
+export interface EditorialClientInterface {
+    getSchema(): Promise<EditorialSchema>;
+    getConfig(): Promise<EditorialConfig>;
+    getContent<T = EditorialData>(options?: GetContentOptions): Promise<T>;
+    getContentByType<T = EditorialDataType>(type: string, options?: GetContentOptions): Promise<T[]>;
+    getContentIds(type: string, options?: GetContentOptions): Promise<string[]>;
+    getContentById<T = EditorialDataItem>(type: string, id: string, options?: GetContentOptions): Promise<T>;
+    createContent<T = EditorialDataItem>(type: string, id: string, data: T): Promise<T>;
+    updateContent<T = EditorialDataItem>(type: string, id: string, data: Partial<T>): Promise<T>;
+    deleteContent(type: string, id: string): Promise<boolean>;
+}
+export { EditorialConfig, EditorialData, EditorialDataItem, EditorialDataType, EditorialSchema, };

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@isardsat/editorial-client",
+  "version": "6.6.1",
+  "description": "JavaScript client for the Editorial CMS API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "dependencies": {
+    "@isardsat/editorial-common": "6.6.1"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.0",
+    "typescript": "5.7.3"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "keywords": [
+    "editorial",
+    "cms",
+    "api",
+    "client",
+    "typescript"
+  ],
+  "scripts": {
+    "compile": "tsc",
+    "compile:watch": "tsc --watch"
+  }
+}

package/src/client.ts

@@ -0,0 +1,206 @@
+import type {
+  EditorialConfig,
+  EditorialData,
+  EditorialDataItem,
+  EditorialDataType,
+  EditorialSchema,
+} from "@isardsat/editorial-common";
+import {
+  EditorialError,
+  EditorialNetworkError,
+  EditorialNotFoundError,
+  EditorialValidationError,
+} from "./errors.js";
+import type {
+  ClientOptions,
+  EditorialClientInterface,
+  GetContentOptions,
+} from "./types.js";
+
+export function createEditorialClient(
+  baseURL: string,
+  options: ClientOptions = {}
+): EditorialClientInterface {
+  const apiBaseURL = new URL("/api/v1/", baseURL);
+  const defaultLocale = options.defaultLocale || "en";
+  const fetchFn = options.fetch || globalThis.fetch;
+  const defaultHeaders = {
+    "Content-Type": "application/json",
+    ...options.headers,
+  };
+  const timeout = options.timeout || 30000;
+
+  async function request<T>(
+    endpoint: string,
+    requestOptions: RequestInit = {}
+  ): Promise<T> {
+    const url = new URL(endpoint, apiBaseURL);
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetchFn(url.toString(), {
+        ...requestOptions,
+        headers: {
+          ...defaultHeaders,
+          ...requestOptions.headers,
+        },
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorMessage = await response
+          .text()
+          .catch(() => response.statusText);
+
+        if (response.status === 404) {
+          throw new EditorialNotFoundError(errorMessage);
+        }
+
+        if (response.status === 400) {
+          throw new EditorialValidationError(errorMessage);
+        }
+
+        throw new EditorialError(
+          errorMessage || `HTTP ${response.status} ${response.statusText}`,
+          response.status,
+          response.statusText
+        );
+      }
+
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+
+      if (error instanceof EditorialError) {
+        throw error;
+      }
+
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new EditorialNetworkError("Request timeout");
+      }
+
+      throw new EditorialNetworkError(
+        `Network error: ${
+          error instanceof Error ? error.message : "Unknown error"
+        }`,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  function buildQueryParams(options: GetContentOptions = {}): URLSearchParams {
+    const params = new URLSearchParams();
+
+    if (options.locale && options.locale !== defaultLocale) {
+      params.append("lang", options.locale);
+    }
+
+    if (options.preview) {
+      params.append("preview", "true");
+    }
+
+    return params;
+  }
+
+  return {
+    async getSchema(): Promise<EditorialSchema> {
+      return request<EditorialSchema>("schema");
+    },
+
+    async getConfig(): Promise<EditorialConfig> {
+      return request<EditorialConfig>("config");
+    },
+
+    async getContent<T = EditorialData>(
+      options: GetContentOptions = {}
+    ): Promise<T> {
+      const params = buildQueryParams(options);
+      const endpoint = params.toString() ? `data?${params}` : "data";
+
+      return request<T>(endpoint);
+    },
+
+    async getContentByType<T = EditorialDataType>(
+      type: string,
+      options: GetContentOptions = {}
+    ): Promise<T[]> {
+      const params = buildQueryParams(options);
+      const endpoint = params.toString()
+        ? `data/${encodeURIComponent(type)}?${params}`
+        : `data/${encodeURIComponent(type)}`;
+
+      const result = await request<Record<string, T>>(endpoint);
+      return Object.values(result) as T[];
+    },
+
+    async getContentIds(
+      type: string,
+      options: GetContentOptions = {}
+    ): Promise<string[]> {
+      const params = new URLSearchParams();
+      if (options.preview) {
+        params.append("preview", "true");
+      }
+
+      const endpoint = params.toString()
+        ? `data/${encodeURIComponent(type)}/ids?${params}`
+        : `data/${encodeURIComponent(type)}/ids`;
+
+      return request<string[]>(endpoint);
+    },
+
+    async getContentById<T = EditorialDataItem>(
+      type: string,
+      id: string,
+      options: GetContentOptions = {}
+    ): Promise<T> {
+      const params = buildQueryParams(options);
+      const endpoint = params.toString()
+        ? `data/${encodeURIComponent(type)}/${encodeURIComponent(id)}?${params}`
+        : `data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`;
+
+      return request<T>(endpoint);
+    },
+
+    async createContent<T = EditorialDataItem>(
+      type: string,
+      id: string,
+      data: T
+    ): Promise<T> {
+      return request<T>(
+        `data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`,
+        {
+          method: "PUT",
+          body: JSON.stringify(data),
+        }
+      );
+    },
+
+    async updateContent<T = EditorialDataItem>(
+      type: string,
+      id: string,
+      data: Partial<T>
+    ): Promise<T> {
+      return request<T>(
+        `data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(data),
+        }
+      );
+    },
+
+    async deleteContent(type: string, id: string): Promise<boolean> {
+      return request<boolean>(
+        `data/${encodeURIComponent(type)}/${encodeURIComponent(id)}`,
+        {
+          method: "DELETE",
+        }
+      );
+    },
+  };
+}

package/src/errors.ts

@@ -0,0 +1,34 @@
+export class EditorialError extends Error {
+  constructor(
+    message: string,
+    public readonly status?: number,
+    public readonly statusText?: string
+  ) {
+    super(message);
+    this.name = "EditorialError";
+  }
+}
+
+export class EditorialNetworkError extends EditorialError {
+  constructor(message: string, public readonly cause?: Error) {
+    super(message);
+    this.name = "EditorialNetworkError";
+  }
+}
+
+export class EditorialNotFoundError extends EditorialError {
+  constructor(resource: string, id?: string) {
+    const message = id
+      ? `${resource} with id '${id}' not found`
+      : `${resource} not found`;
+    super(message, 404, "Not Found");
+    this.name = "EditorialNotFoundError";
+  }
+}
+
+export class EditorialValidationError extends EditorialError {
+  constructor(message: string) {
+    super(message, 400, "Bad Request");
+    this.name = "EditorialValidationError";
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export { createEditorialClient } from "./client.js";
+export {
+  EditorialError,
+  EditorialNetworkError,
+  EditorialNotFoundError,
+  EditorialValidationError,
+} from "./errors.js";
+export type {
+  ClientOptions,
+  EditorialClientInterface,
+  EditorialConfig,
+  EditorialData,
+  EditorialDataItem,
+  EditorialDataType,
+  EditorialSchema,
+  GetContentOptions,
+} from "./types.js";

package/src/types.ts

@@ -0,0 +1,54 @@
+import type {
+  EditorialConfig,
+  EditorialData,
+  EditorialDataItem,
+  EditorialDataType,
+  EditorialSchema,
+} from "@isardsat/editorial-common";
+
+export interface ClientOptions {
+  fetch?: typeof globalThis.fetch;
+  headers?: Record<string, string>;
+  defaultLocale?: string;
+  timeout?: number;
+}
+
+export interface GetContentOptions {
+  locale?: string;
+  preview?: boolean;
+}
+
+export interface EditorialClientInterface {
+  getSchema(): Promise<EditorialSchema>;
+  getConfig(): Promise<EditorialConfig>;
+  getContent<T = EditorialData>(options?: GetContentOptions): Promise<T>;
+  getContentByType<T = EditorialDataType>(
+    type: string,
+    options?: GetContentOptions
+  ): Promise<T[]>;
+  getContentIds(type: string, options?: GetContentOptions): Promise<string[]>;
+  getContentById<T = EditorialDataItem>(
+    type: string,
+    id: string,
+    options?: GetContentOptions
+  ): Promise<T>;
+  createContent<T = EditorialDataItem>(
+    type: string,
+    id: string,
+    data: T
+  ): Promise<T>;
+  updateContent<T = EditorialDataItem>(
+    type: string,
+    id: string,
+    data: Partial<T>
+  ): Promise<T>;
+  deleteContent(type: string, id: string): Promise<boolean>;
+}
+
+export {
+  EditorialConfig,
+  EditorialData,
+  EditorialDataItem,
+  EditorialDataType,
+  EditorialSchema,
+};

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@tsconfig/node22/tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "dist",
+    "lib": ["ES2022", "DOM"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}