@bernierllc/contentful-cma-client 1.0.2

package/dist/ContentfulCMAClient.js

@@ -0,0 +1,538 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulCMAClient = void 0;
+const contentful_management_1 = __importDefault(require("contentful-management"));
+const logger_1 = require("@bernierllc/logger");
+class ContentfulCMAClient {
+    constructor(config) {
+        // Set defaults
+        this.config = {
+            environmentId: 'master',
+            host: 'api.contentful.com',
+            retryOnError: true,
+            timeout: 30000,
+            ...config
+        };
+        // Initialize logger
+        this.logger = new logger_1.Logger({
+            level: logger_1.LogLevel.INFO,
+            transports: [new logger_1.ConsoleTransport()],
+            context: {
+                service: 'contentful-cma-client',
+                version: '1.0.0',
+                spaceId: config.spaceId,
+                environmentId: this.config.environmentId
+            }
+        });
+        // Create contentful-management client with plain API
+        this.client = contentful_management_1.default.createClient({
+            accessToken: config.accessToken,
+            host: this.config.host
+        }, {
+            type: 'plain',
+            defaults: {
+                spaceId: config.spaceId,
+                environmentId: this.config.environmentId
+            }
+        });
+        this.logger.info('ContentfulCMAClient initialized', {
+            spaceId: config.spaceId,
+            environmentId: this.config.environmentId,
+            host: this.config.host
+        });
+    }
+    /**
+     * Get entry by ID
+     */
+    async getEntry(entryId) {
+        try {
+            this.logger.debug('Getting entry', { entryId });
+            const entry = await this.client.entry.get({ entryId });
+            this.logger.debug('Entry retrieved', { entryId });
+            return entry;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get entry', errorObj, { entryId });
+            throw error;
+        }
+    }
+    /**
+     * Get multiple entries with optional query parameters
+     */
+    async getEntries(query) {
+        try {
+            this.logger.debug('Getting entries', { query: query || {} });
+            const response = await this.client.entry.getMany({
+                query: query
+            });
+            this.logger.debug('Entries retrieved', {
+                count: response.items.length,
+                total: response.total
+            });
+            return response.items;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get entries', errorObj, { query: query || {} });
+            throw error;
+        }
+    }
+    /**
+     * Get all entries with automatic pagination
+     */
+    async getAllEntries(query) {
+        const all = [];
+        let skip = 0;
+        const limit = 100;
+        this.logger.debug('Getting all entries with pagination', { query: query || {} });
+        let hasMore = true;
+        while (hasMore) {
+            const response = await this.client.entry.getMany({
+                query: { ...query, skip, limit }
+            });
+            all.push(...response.items);
+            this.logger.debug('Retrieved entry batch', {
+                batch: response.items.length,
+                total: all.length,
+                remaining: response.total - (skip + response.items.length)
+            });
+            if (skip + response.items.length >= response.total) {
+                hasMore = false;
+            }
+            else {
+                skip += response.items.length;
+            }
+        }
+        this.logger.info('All entries retrieved', { totalCount: all.length });
+        return all;
+    }
+    /**
+     * Create entry
+     */
+    async createEntry(contentTypeId, fields, options) {
+        try {
+            this.logger.debug('Creating entry', { contentTypeId, options: options || {} });
+            const entry = await this.client.entry.create({ contentTypeId, ...(options?.entryId ? { entryId: options.entryId } : {}) }, { fields: fields });
+            this.logger.info('Entry created', {
+                entryId: entry.sys.id,
+                contentTypeId
+            });
+            return entry;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create entry', errorObj, { contentTypeId });
+            throw error;
+        }
+    }
+    /**
+     * Update entry
+     */
+    async updateEntry(entryId, fields, version, _options) {
+        try {
+            this.logger.debug('Updating entry', { entryId, version });
+            // Type assertion needed due to contentful-management strict typing
+            const entry = await this.client.entry.update({ entryId }, {
+                sys: { version },
+                fields: fields
+            });
+            this.logger.info('Entry updated', { entryId, newVersion: entry.sys.version });
+            return entry;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to update entry', errorObj, { entryId, version });
+            throw error;
+        }
+    }
+    /**
+     * Publish entry
+     */
+    async publishEntry(entryId, version) {
+        try {
+            this.logger.debug('Publishing entry', { entryId, version });
+            // Type assertion needed due to contentful-management strict typing
+            const entry = await this.client.entry.publish({ entryId }, { sys: { version } });
+            this.logger.info('Entry published', {
+                entryId,
+                publishedVersion: entry.sys.publishedVersion
+            });
+            return entry;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to publish entry', errorObj, { entryId, version });
+            throw error;
+        }
+    }
+    /**
+     * Unpublish entry
+     */
+    async unpublishEntry(entryId) {
+        try {
+            this.logger.debug('Unpublishing entry', { entryId });
+            const entry = await this.client.entry.unpublish({ entryId });
+            this.logger.info('Entry unpublished', { entryId });
+            return entry;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to unpublish entry', errorObj, { entryId });
+            throw error;
+        }
+    }
+    /**
+     * Archive entry
+     */
+    async archiveEntry(entryId, version) {
+        try {
+            this.logger.debug('Archiving entry', { entryId, version });
+            // Type assertion needed due to contentful-management strict typing
+            const entry = await this.client.entry.archive({ entryId, version });
+            this.logger.info('Entry archived', { entryId });
+            return entry;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to archive entry', errorObj, { entryId, version });
+            throw error;
+        }
+    }
+    /**
+     * Unarchive entry
+     */
+    async unarchiveEntry(entryId) {
+        try {
+            this.logger.debug('Unarchiving entry', { entryId });
+            const entry = await this.client.entry.unarchive({ entryId });
+            this.logger.info('Entry unarchived', { entryId });
+            return entry;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to unarchive entry', errorObj, { entryId });
+            throw error;
+        }
+    }
+    /**
+     * Delete entry
+     */
+    async deleteEntry(entryId) {
+        try {
+            this.logger.debug('Deleting entry', { entryId });
+            await this.client.entry.delete({ entryId });
+            this.logger.info('Entry deleted', { entryId });
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to delete entry', errorObj, { entryId });
+            throw error;
+        }
+    }
+    /**
+     * Get asset by ID
+     */
+    async getAsset(assetId) {
+        try {
+            this.logger.debug('Getting asset', { assetId });
+            const asset = await this.client.asset.get({ assetId });
+            this.logger.debug('Asset retrieved', { assetId });
+            return asset;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get asset', errorObj, { assetId });
+            throw error;
+        }
+    }
+    /**
+     * Get multiple assets with optional query parameters
+     */
+    async getAssets(query) {
+        try {
+            this.logger.debug('Getting assets', { query: query || {} });
+            const response = await this.client.asset.getMany({
+                query: query
+            });
+            this.logger.debug('Assets retrieved', {
+                count: response.items.length,
+                total: response.total
+            });
+            return response.items;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get assets', errorObj, { query: query || {} });
+            throw error;
+        }
+    }
+    /**
+     * Get all assets with automatic pagination
+     */
+    async getAllAssets(query) {
+        const all = [];
+        let skip = 0;
+        const limit = 100;
+        this.logger.debug('Getting all assets with pagination', { query: query || {} });
+        let hasMore = true;
+        while (hasMore) {
+            const response = await this.client.asset.getMany({
+                query: { ...query, skip, limit }
+            });
+            all.push(...response.items);
+            this.logger.debug('Retrieved asset batch', {
+                batch: response.items.length,
+                total: all.length,
+                remaining: response.total - (skip + response.items.length)
+            });
+            if (skip + response.items.length >= response.total) {
+                hasMore = false;
+            }
+            else {
+                skip += response.items.length;
+            }
+        }
+        this.logger.info('All assets retrieved', { totalCount: all.length });
+        return all;
+    }
+    /**
+     * Create asset
+     */
+    async createAsset(fields, options) {
+        try {
+            this.logger.debug('Creating asset', { options: options || {} });
+            // Type assertion needed due to contentful-management strict typing
+            const asset = await this.client.asset.create({ ...(options?.assetId ? { assetId: options.assetId } : {}) }, { fields });
+            this.logger.info('Asset created', { assetId: asset.sys.id });
+            return asset;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to create asset', errorObj);
+            throw error;
+        }
+    }
+    /**
+     * Process asset (for uploaded files)
+     */
+    async processAsset(assetId, version, locale = 'en-US') {
+        try {
+            this.logger.debug('Processing asset', { assetId, version, locale });
+            // Type assertion needed due to contentful-management strict typing
+            const asset = await this.client.asset.processForLocale({ assetId, version }, { sys: { version } }, locale);
+            this.logger.info('Asset processing started', { assetId });
+            return asset;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to process asset', errorObj, {
+                assetId,
+                version,
+                locale
+            });
+            throw error;
+        }
+    }
+    /**
+     * Publish asset
+     */
+    async publishAsset(assetId, version) {
+        try {
+            this.logger.debug('Publishing asset', { assetId, version });
+            // Type assertion needed due to contentful-management strict typing
+            const asset = await this.client.asset.publish({ assetId }, { sys: { version } });
+            this.logger.info('Asset published', {
+                assetId,
+                publishedVersion: asset.sys.publishedVersion
+            });
+            return asset;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to publish asset', errorObj, { assetId, version });
+            throw error;
+        }
+    }
+    /**
+     * Unpublish asset
+     */
+    async unpublishAsset(assetId) {
+        try {
+            this.logger.debug('Unpublishing asset', { assetId });
+            const asset = await this.client.asset.unpublish({ assetId });
+            this.logger.info('Asset unpublished', { assetId });
+            return asset;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to unpublish asset', errorObj, { assetId });
+            throw error;
+        }
+    }
+    /**
+     * Delete asset
+     */
+    async deleteAsset(assetId) {
+        try {
+            this.logger.debug('Deleting asset', { assetId });
+            await this.client.asset.delete({ assetId });
+            this.logger.info('Asset deleted', { assetId });
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to delete asset', errorObj, { assetId });
+            throw error;
+        }
+    }
+    /**
+     * Get content type by ID
+     */
+    async getContentType(contentTypeId) {
+        try {
+            this.logger.debug('Getting content type', { contentTypeId });
+            const contentType = await this.client.contentType.get({ contentTypeId });
+            this.logger.debug('Content type retrieved', { contentTypeId });
+            return contentType;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get content type', errorObj, { contentTypeId });
+            throw error;
+        }
+    }
+    /**
+     * Get all content types
+     */
+    async getContentTypes(query) {
+        try {
+            this.logger.debug('Getting content types', { query: query || {} });
+            const response = await this.client.contentType.getMany({
+                query: query
+            });
+            this.logger.info('Content types retrieved', { count: response.items.length });
+            return response.items;
+        }
+        catch (error) {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            this.logger.error('Failed to get content types', errorObj, { query: query || {} });
+            throw error;
+        }
+    }
+    /**
+     * Bulk create entries
+     */
+    async bulkCreateEntries(entries) {
+        const results = {
+            successful: [],
+            failed: []
+        };
+        this.logger.info('Starting bulk entry creation', { count: entries.length });
+        for (const entry of entries) {
+            try {
+                const created = await this.createEntry(entry.contentTypeId, entry.fields, { entryId: entry.entryId });
+                results.successful.push(created);
+            }
+            catch (error) {
+                results.failed.push({
+                    item: { contentTypeId: entry.contentTypeId, fields: entry.fields },
+                    error: this.getErrorMessage(error)
+                });
+            }
+        }
+        this.logger.info('Bulk entry creation completed', {
+            successful: results.successful.length,
+            failed: results.failed.length
+        });
+        return results;
+    }
+    /**
+     * Bulk delete entries
+     */
+    async bulkDeleteEntries(entryIds) {
+        const results = {
+            successful: [],
+            failed: []
+        };
+        this.logger.info('Starting bulk entry deletion', { count: entryIds.length });
+        for (const entryId of entryIds) {
+            try {
+                await this.deleteEntry(entryId);
+                results.successful.push(entryId);
+            }
+            catch (error) {
+                results.failed.push({
+                    item: entryId,
+                    error: this.getErrorMessage(error)
+                });
+            }
+        }
+        this.logger.info('Bulk entry deletion completed', {
+            successful: results.successful.length,
+            failed: results.failed.length
+        });
+        return results;
+    }
+    /**
+     * Bulk publish entries
+     */
+    async bulkPublishEntries(entries) {
+        const results = {
+            successful: [],
+            failed: []
+        };
+        this.logger.info('Starting bulk entry publishing', { count: entries.length });
+        for (const entry of entries) {
+            try {
+                const published = await this.publishEntry(entry.entryId, entry.version);
+                results.successful.push(published);
+            }
+            catch (error) {
+                results.failed.push({
+                    item: entry,
+                    error: this.getErrorMessage(error)
+                });
+            }
+        }
+        this.logger.info('Bulk entry publishing completed', {
+            successful: results.successful.length,
+            failed: results.failed.length
+        });
+        return results;
+    }
+    /**
+     * Helper method to extract error message
+     */
+    getErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+        return 'Unknown error';
+    }
+    /**
+     * Get current space ID
+     */
+    getSpaceId() {
+        return this.config.spaceId;
+    }
+    /**
+     * Get current environment ID
+     */
+    getEnvironmentId() {
+        return this.config.environmentId;
+    }
+}
+exports.ContentfulCMAClient = ContentfulCMAClient;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { ContentfulCMAClient } from './ContentfulCMAClient';
+export { CMAQueryOptions, CMAEntryCreateOptions, CMAEntryUpdateOptions, CMAAssetCreateOptions, CMABulkOperationResult } from './types';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentfulCMAClient = void 0;
+var ContentfulCMAClient_1 = require("./ContentfulCMAClient");
+Object.defineProperty(exports, "ContentfulCMAClient", { enumerable: true, get: function () { return ContentfulCMAClient_1.ContentfulCMAClient; } });

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Query options for CMA operations
+ */
+export interface CMAQueryOptions {
+    skip?: number;
+    limit?: number;
+    order?: string;
+    locale?: string;
+    content_type?: string;
+    [key: string]: string | number | undefined;
+}
+/**
+ * Options for creating entries
+ */
+export interface CMAEntryCreateOptions {
+    entryId?: string;
+}
+/**
+ * Options for updating entries
+ */
+export interface CMAEntryUpdateOptions {
+    locale?: string;
+}
+/**
+ * Options for creating assets
+ */
+export interface CMAAssetCreateOptions {
+    assetId?: string;
+}
+/**
+ * Result of bulk operations
+ */
+export interface CMABulkOperationResult<T> {
+    successful: T[];
+    failed: Array<{
+        item: unknown;
+        error: string;
+    }>;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });

package/jest.config.cjs

@@ -0,0 +1,31 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: '<rootDir>/../../../jest-environment-node-fixed.cjs',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.test.ts',
+    '!src/**/__tests__/**'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 70,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    }
+  },
+  moduleNameMapper: {
+    '^@bernierllc/contentful-types$': '<rootDir>/../contentful-types/src',
+    '^@bernierllc/logger$': '<rootDir>/../logger/src'
+  }
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@bernierllc/contentful-cma-client",
+  "version": "1.0.2",
+  "description": "Thin wrapper around contentful-management SDK with consistent error handling, logging, and typed interfaces",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:run": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "contentful",
+    "cma",
+    "content-management",
+    "api-wrapper",
+    "bernierllc"
+  ],
+  "author": "Bernier LLC",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "dependencies": {
+    "@bernierllc/contentful-types": "workspace:*",
+    "@bernierllc/logger": "^1.0.1",
+    "contentful-management": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}