@pintawebware/strapi-sync 1.0.4

package/lib/strapi-client.js

@@ -0,0 +1,347 @@
+const axios = require('axios');
+
+function unwrapError(error) {
+  if (error && error.errors && Array.isArray(error.errors) && error.errors.length > 0) {
+    return error.errors[0];
+  }
+  return error;
+}
+
+function formatStrapiError(error, context = '') {
+  const err = unwrapError(error);
+  if (!err.response) {
+    const msg = err.message || err.code || String(err);
+    const contextStr = context ? ` (${context})` : '';
+    return `Request failed${contextStr}. ${msg}. Check STRAPI_URL and network.`;
+  }
+  const status = err.response.status;
+  const msg = err.response.data?.error?.message || err.response.data?.message || err.message;
+  const contextStr = context ? ` (${context})` : '';
+  switch (status) {
+    case 401:
+      return `Strapi returned 401 Unauthorized${contextStr}. Check that STRAPI_API_TOKEN is set correctly and has access to the API.`;
+    case 403:
+      return `Strapi returned 403 Forbidden${contextStr}. The API token may not have permission for this action.`;
+    case 404:
+      return `Strapi returned 404 Not Found${contextStr}. ${msg || 'Resource not found.'}`;
+    case 405: {
+      const isEntry = context && /entry|content/i.test(context);
+      return isEntry
+        ? `Strapi returned 405 Method Not Allowed${contextStr}. The content type may not exist yet or the API may not allow this. If you just wrote schema files, restart Strapi to load the new content type, then run strapi-sync again. Otherwise check API permissions in Strapi Admin.`
+        : `Strapi returned 405 Method Not Allowed${contextStr}. This operation is not supported by the Strapi API.`;
+    }
+    case 500:
+      return `Strapi server error (500)${contextStr}. ${msg || 'Try again later.'}`;
+    default:
+      return `Strapi request failed (${status})${contextStr}. ${msg || err.message}`;
+  }
+}
+
+function sanitizePayload(data) {
+  const payload = { ...(data || {}) };
+  delete payload.id;
+  delete payload.documentId;
+  return payload;
+}
+
+class StrapiSyncClient {
+  constructor(config) {
+    this.client = axios.create({
+      baseURL: config.baseURL,
+      timeout: config.timeout || 30000,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(config.apiToken && { Authorization: `Bearer ${config.apiToken}` }),
+      },
+    });
+  }
+
+  async ping() {
+    try {
+      await this.client.get('/api', { timeout: 5000 });
+      return true;
+    } catch (e) {
+      if (e.code === 'ECONNREFUSED' || e.code === 'ECONNRESET' || e.code === 'ETIMEDOUT') return false;
+      if (e.response && typeof e.response.status === 'number') return true;
+      return false;
+    }
+  }
+
+  async _getContentTypeBuilderPayload() {
+    const response = await this.client.get('/api/content-type-builder/content-types');
+    return response.data?.data ?? response.data;
+  }
+
+  async getAllContentTypes() {
+    try {
+      const raw = await this._getContentTypeBuilderPayload();
+      if (!raw || typeof raw !== 'object') return [];
+      const list = Array.isArray(raw)
+        ? raw
+        : raw.contentTypes
+          ? Object.values(raw.contentTypes)
+          : Object.keys(raw).map((uid) => ({ uid }));
+      return list
+        .filter((x) => x && (x.uid || x.apiID || typeof x === 'string') && x.schema)
+        .map((x) => {
+          const uid = x.uid || x.apiID || x;
+          const str = typeof uid === 'string' ? uid : '';
+          const schema = x.schema || {};
+          return {
+            name: schema.displayName,
+            uid: str,
+            kind: schema.kind,
+            apiID: x.apiID || schema.displayName,
+            pluralName: schema.pluralName ? String(schema.pluralName).toLowerCase() : null,
+            schema
+          };
+        })
+        .filter((x) => x.uid.startsWith('api::'));
+    } catch (error) {
+      const status = error.response?.status;
+      if (status === 401 || status === 403) {
+        const e = new Error(formatStrapiError(error, 'fetching content types list'));
+        e.status = status;
+        throw e;
+      }
+      if (status === 404 || status === 405) return [];
+      throw new Error(formatStrapiError(error, 'fetching content types list'));
+    }
+  }
+
+  async getAllComponents() {
+    try {
+      let list = [];
+      try {
+        const response = await this.client.get('/api/content-type-builder/components');
+        const raw = response.data?.data ?? response.data;
+        if (raw) list = Array.isArray(raw) ? raw : (raw.components ? Object.values(raw.components) : []);
+      } catch (e) {
+        if (e.response?.status !== 404 && e.response?.status !== 405) throw e;
+        const payload = await this._getContentTypeBuilderPayload();
+        if (payload && typeof payload === 'object' && payload.components)
+          list = Array.isArray(payload.components) ? payload.components : Object.values(payload.components);
+      }
+      return list
+        .filter((c) => c && (c.uid || (c.category && c.schema)))
+        .map((c) => {
+          const uid = c.uid || (c.category && c.apiId ? `${c.category}.${c.apiId}` : (c.category && c.schema?.displayName ? `${c.category}.${String(c.schema.displayName).replace(/\s+/g, '-').toLowerCase()}` : ''));
+          const schema = c.schema || c;
+          return uid ? { uid: String(uid), schema: typeof schema === 'object' ? schema : {} } : null;
+        })
+        .filter(Boolean);
+    } catch (error) {
+      const status = error.response?.status;
+      if (status === 401 || status === 403) {
+        const e = new Error(formatStrapiError(error, 'fetching components list'));
+        e.status = status;
+        throw e;
+      }
+      if (status === 404 || status === 405) return [];
+      return [];
+    }
+  }
+
+  async getContentTypeSchema(contentType) {
+    try {
+      const response = await this.client.get(`/api/content-type-builder/content-types/api::${contentType}.${contentType}`);
+      return response.data;
+    } catch (error) {
+      if (error.response?.status === 404) {
+        return null;
+      }
+      const e = new Error(formatStrapiError(error, `content type "${contentType}"`));
+      e.status = error.response?.status;
+      throw e;
+    }
+  }
+
+  getApiId(contentType, options = {}) {
+    let id = options.apiId ?? (contentType.endsWith('s') ? contentType : `${contentType}s`);
+    if (typeof id !== 'string') return id;
+    if (options.singleType === true && id.endsWith('s')) return id.slice(0, -1);
+    if (options.singleType === false && !id.endsWith('s')) return id.endsWith('y') ? id.slice(0, -1) + 'ies' : id + 's';
+    return id;
+  }
+
+  async getLocales() {
+    try {
+      const r = await this.client.get('/api/i18n/locales');
+      const payload = r.data;
+      const list = Array.isArray(payload)
+        ? payload
+        : Array.isArray(payload?.data)
+          ? payload.data
+          : Array.isArray(payload?.locales)
+            ? payload.locales
+            : [];
+      if (list.length > 0) {
+        return list
+          .map((l) => (typeof l === 'string' ? l : (l.code || l.locale || l.name || l.id)))
+          .filter(Boolean);
+      }
+      return ['en'];
+    } catch (_) {
+      return ['en'];
+    }
+  }
+
+  async getEntries(contentType, filters = {}, options = {}) {
+    const { singleType = false, pageSize, locale, localized, populate = '*' } = options;
+    const apiId = this.getApiId(contentType, options);
+    const fetchOne = async (loc) => {
+      const params = { ...filters };
+      if (pageSize != null) params['pagination[pageSize]'] = pageSize;
+      if (loc != null && loc !== '') params.locale = loc;
+      if (populate != null) params.populate = populate;
+      if (singleType) {
+        const response = await this.client.get(`/api/${apiId}`, { params });
+        const data = response.data?.data;
+        // console.log('data', data);
+        return data ? [data] : [];
+      }
+      let all = [];
+      let page = 1;
+      let hasMore = true;
+      while (hasMore) {
+        params['pagination[page]'] = page;
+        const response = await this.client.get(`/api/${apiId}`, { params });
+        const data = response.data?.data;
+        const list = Array.isArray(data) ? data : [];
+        all = all.concat(list);
+        const meta = response.data?.meta?.pagination;
+        if (!meta || meta.pageCount == null || meta.pageCount <= page) hasMore = false;
+        else hasMore = page < meta.pageCount;
+        page += 1;
+      }
+      return all;
+    };
+    try {
+      if (locale === 'all') {
+        if (localized === false) {
+          return await fetchOne(undefined);
+        }
+        const locales = await this.getLocales();
+        let merged = [];
+        for (const loc of locales) {
+          let list = [];
+          try {
+            list = await fetchOne(loc);
+          } catch (error) {
+            if (error.response?.status === 404) continue;
+            throw error;
+          }
+          const withLocale = list.map((e) => (
+            e
+              ? { ...e, locale: e.locale ?? e.localization?.locale ?? loc }
+              : e
+          ));
+          merged = merged.concat(withLocale);
+        }
+        const seen = new Set();
+        return merged.filter((entry) => {
+          if (!entry || typeof entry !== 'object') return false;
+          const key = `${entry.documentId ?? entry.id ?? ''}_${entry.locale ?? ''}`;
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        });
+      }
+      return await fetchOne(locale);
+    } catch (error) {
+      if (error.response?.status === 404) {
+        return [];
+      }
+      const e = new Error(formatStrapiError(error, `fetching ${contentType} entries`));
+      e.status = error.response?.status;
+      throw e;
+    }
+  }
+
+  async createEntry(contentType, data, options = {}) {
+    const { singleType = false, locale } = options;
+    const apiId = this.getApiId(contentType, options);
+    const params = locale != null && locale !== '' ? { locale } : {};
+    const payload = sanitizePayload(data);
+    if (singleType) {
+      try {
+        const { data } = await this.client.put(`/api/${apiId}`, { data: payload }, { params });
+        return data;
+      } catch (error) {
+        throw new Error(formatStrapiError(error, `creating ${contentType} entry`));
+      }
+    } 
+    try {
+      const { data } = await this.client.post(`/api/${apiId}`, { data: payload }, { params });
+      return data;
+    } catch (error) {
+      throw new Error(formatStrapiError(error, `creating ${contentType} entry`));
+    }
+  }
+
+  async updateEntry(contentType, id, data, options = {}) {
+    const { singleType = false, locale } = options;
+    const apiId = this.getApiId(contentType, options);
+    const params = locale != null && locale !== '' ? { locale } : {};
+    const payload = sanitizePayload(data);
+    if (singleType) {
+      try {
+        const response = await this.client.put(`/api/${apiId}`, { data: payload }, { params });
+        return response.data;
+      } catch (error) {
+        throw new Error(formatStrapiError(error, `updating ${contentType} entry`));
+      }
+    }
+    try {
+      const response = await this.client.put(`/api/${apiId}/${id}`, { data: payload }, { params });
+      return response.data;
+    } catch (error) {
+      throw new Error(formatStrapiError(error, `updating ${contentType} entry ${id}`));
+    }
+  }
+
+  async deleteEntry(contentType, id, options = {}) {
+    const apiId = this.getApiId(contentType, options);
+    const params = options.locale != null && options.locale !== '' ? { locale: options.locale } : {};
+    try {
+      await this.client.delete(`/api/${apiId}/${id}`, { params });
+    } catch (error) {
+      throw new Error(formatStrapiError(error, `deleting ${contentType} entry ${id}`));
+    }
+  }
+
+  async upsertContent(contentType, objData, options = {}) {
+    const { singleType = false } = options;
+    const data = objData.data;
+
+    if (Array.isArray(data)) {
+      for (const item of data) {
+        await this.upsertContent(contentType, { data: item, file: objData.file }, options);
+      }
+      return;
+    }
+
+    if (singleType) {
+      await this.updateEntry(contentType, null, data, options);
+      return;
+    }
+
+    if (data.id) {
+      const existing = await this.getEntries(contentType, {
+        filters: { id: { $eq: data.id } }
+      }, options);
+
+      if (existing.length > 0) {
+        const entryId = existing[0].documentId ?? existing[0].id;
+        await this.updateEntry(contentType, entryId, data, options);
+      } else {
+        await this.createEntry(contentType, data, options);
+      }
+    } else {
+      await this.createEntry(contentType, data, options);
+    }
+  }
+}
+
+module.exports = { StrapiSyncClient };
+