content-serialization 0.0.0

package/dist/server/index.mjs

@@ -0,0 +1,375 @@
+import path from "path";
+import fs from "fs";
+import yaml from "js-yaml";
+import crypto from "crypto";
+const bootstrap = ({ strapi: strapi2 }) => {
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const register = ({ strapi: strapi2 }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi: strapi2 }) => ({
+  index(ctx) {
+    ctx.body = strapi2.plugin("content-serialization").service("service").getWelcomeMessage();
+  },
+  async pull(ctx) {
+    try {
+      const { stats, logs } = await strapi2.plugin("content-serialization").service("serialization").pull();
+      ctx.body = { status: "success", stats, logs };
+    } catch (e) {
+      ctx.badRequest(e.message);
+    }
+  },
+  async push(ctx) {
+    try {
+      const { stats, logs } = await strapi2.plugin("content-serialization").service("serialization").push();
+      ctx.body = { status: "success", stats, logs };
+    } catch (e) {
+      ctx.badRequest(e.message);
+    }
+  }
+});
+const controllers = {
+  controller
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = () => ({
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/",
+      // name of the controller file & the method.
+      handler: "controller.index",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/perform-pull",
+      handler: "controller.pull",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/perform-push",
+      handler: "controller.push",
+      config: {
+        policies: []
+      }
+    }
+  ]
+});
+const adminAPIRoutes = () => ({
+  type: "admin",
+  routes: [
+    {
+      method: "POST",
+      path: "/perform-pull",
+      handler: "controller.pull",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/perform-push",
+      handler: "controller.push",
+      config: {
+        policies: []
+      }
+    }
+  ]
+});
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const service = ({ strapi: strapi2 }) => ({
+  getWelcomeMessage() {
+    return "Welcome to Strapi 🚀";
+  }
+});
+const SERIALIZATION_DIR = path.join(process.cwd(), "content_serialization");
+const CHECKSUM_FILE = path.join(SERIALIZATION_DIR, ".checksums.json");
+function getHash(content) {
+  return crypto.createHash("md5").update(content).digest("hex");
+}
+function loadChecksums() {
+  try {
+    if (fs.existsSync(CHECKSUM_FILE)) {
+      return JSON.parse(fs.readFileSync(CHECKSUM_FILE, "utf8"));
+    }
+  } catch (e) {
+  }
+  return {};
+}
+function saveChecksums(checksums) {
+  try {
+    fs.writeFileSync(CHECKSUM_FILE, JSON.stringify(checksums, null, 2));
+  } catch (e) {
+    strapi.log.warn(`Failed to save checksums: ${e.message}`);
+  }
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+}
+function sanitizeFilename(name) {
+  return name.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+}
+function sanitizeUser(user) {
+  if (!user || typeof user !== "object") return user;
+  return {
+    id: user.id,
+    documentId: user.documentId,
+    firstname: user.firstname,
+    lastname: user.lastname,
+    username: user.username
+  };
+}
+function recursiveSanitize(data, attributes, componentSchemas) {
+  if (!data || typeof data !== "object") return data;
+  if (Array.isArray(data)) {
+    return data.map((item) => recursiveSanitize(item, attributes, componentSchemas));
+  }
+  const sanitized = {};
+  const keys = Object.keys(data);
+  let currentAttributes = attributes;
+  if (data.__component) {
+    const compSchema = componentSchemas[data.__component];
+    if (compSchema) {
+      currentAttributes = compSchema.attributes;
+      sanitized.__component = data.__component;
+    }
+  }
+  keys.forEach((key) => {
+    if (key === "__component") return;
+    if (["id", "documentId", "createdAt", "updatedAt", "publishedAt", "createdBy", "updatedBy", "locale", "localizations"].includes(key)) return;
+    const value = data[key];
+    const attr = currentAttributes ? currentAttributes[key] : null;
+    if (!attr) {
+      sanitized[key] = value;
+      return;
+    }
+    if (attr.type === "relation" || attr.type === "media") {
+      if (Array.isArray(value)) {
+        sanitized[key] = value.map((v) => v?.documentId || v?.id).filter((v) => v);
+      } else if (value && typeof value === "object") {
+        sanitized[key] = value.documentId || value.id;
+      } else {
+        sanitized[key] = value;
+      }
+    } else if (attr.type === "component") {
+      const compSchema = componentSchemas[attr.component];
+      const compAttributes = compSchema ? compSchema.attributes : {};
+      sanitized[key] = recursiveSanitize(value, compAttributes, componentSchemas);
+    } else if (attr.type === "dynamiczone") {
+      sanitized[key] = recursiveSanitize(value, null, componentSchemas);
+    } else {
+      sanitized[key] = value;
+    }
+  });
+  return sanitized;
+}
+function enforceSchemaStructure(data, attributes) {
+  if (data.createdBy) data.createdBy = sanitizeUser(data.createdBy);
+  if (data.updatedBy) data.updatedBy = sanitizeUser(data.updatedBy);
+  const ordered = {};
+  const commonKeys = ["id", "documentId", "title", "name", "slug"];
+  commonKeys.forEach((key) => {
+    if (data[key] !== void 0) ordered[key] = data[key];
+  });
+  if (attributes) {
+    Object.keys(attributes).forEach((key) => {
+      if (data[key] !== void 0) ordered[key] = data[key];
+    });
+  }
+  Object.keys(data).forEach((key) => {
+    if (ordered[key] === void 0) ordered[key] = data[key];
+  });
+  return ordered;
+}
+function getComponentSchemas() {
+  const schemas = {};
+  Object.keys(strapi.components).forEach((uid) => {
+    schemas[uid] = strapi.components[uid];
+  });
+  return schemas;
+}
+const serialization = ({ strapi: strapi2 }) => ({
+  async pull() {
+    ensureDir(SERIALIZATION_DIR);
+    const stats = { fetched: 0, skipped: 0, deleted: 0, errors: 0 };
+    const checksums = loadChecksums();
+    const logs = [];
+    const contentTypes2 = Object.keys(strapi2.contentTypes).filter((uid) => uid.startsWith("api::")).map((uid) => strapi2.contentTypes[uid]);
+    for (const contentType of contentTypes2) {
+      const typeName = contentType.collectionName || contentType.info.pluralName;
+      const singularName = contentType.info.singularName;
+      const uid = contentType.uid;
+      const typeDir = path.join(SERIALIZATION_DIR, typeName);
+      ensureDir(typeDir);
+      const processedFiles = /* @__PURE__ */ new Set();
+      logs.push(`
+--- Processing ${typeName} ---`);
+      try {
+        const processItem = (item, filename) => {
+          const filePath = path.join(typeDir, filename);
+          const structuredData = enforceSchemaStructure(item, contentType.attributes);
+          const yamlContent = yaml.dump(structuredData);
+          const relPath = path.join(typeName, filename).replace(/\\/g, "/");
+          const hash = getHash(yamlContent);
+          checksums[relPath] = hash;
+          let hasChanges = true;
+          if (fs.existsSync(filePath)) {
+            if (fs.readFileSync(filePath, "utf8") === yamlContent) hasChanges = false;
+          }
+          if (hasChanges) {
+            fs.writeFileSync(filePath, yamlContent);
+            stats.fetched++;
+            logs.push(`[FETCHED] ${filename}`);
+          } else {
+            stats.skipped++;
+            logs.push(`[SKIPPED] ${filename}`);
+          }
+          processedFiles.add(filename);
+        };
+        const items = await strapi2.documents(uid).findMany({
+          populate: "*",
+          publicationState: "preview",
+          limit: 1e4
+        });
+        const itemArray = Array.isArray(items) ? items : [items];
+        if (contentType.kind === "singleType") {
+          const item = await strapi2.documents(uid).findFirst({ populate: "*" });
+          if (item) {
+            processItem(item, `${singularName}.yml`);
+          }
+        } else {
+          itemArray.forEach((item) => {
+            const nameKey = item.slug || item.title || item.name || item.documentId || item.id;
+            processItem(item, `${sanitizeFilename(String(nameKey))}.yml`);
+          });
+        }
+        fs.readdirSync(typeDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml")).forEach((file) => {
+          if (!processedFiles.has(file)) {
+            fs.unlinkSync(path.join(typeDir, file));
+            stats.deleted++;
+            logs.push(`[DELETED] ${file}`);
+          }
+        });
+      } catch (e) {
+        stats.errors++;
+        logs.push(`[ERROR] ${uid}: ${e.message}`);
+        strapi2.log.error(`[Serialization] Error processing ${uid}: ${e.message}`);
+      }
+    }
+    saveChecksums(checksums);
+    logs.push(`
+-----------------------------------`);
+    logs.push(`PULL SUMMARY`);
+    logs.push(`-----------------------------------`);
+    logs.push(`Fetched: ${stats.fetched}`);
+    logs.push(`Deleted: ${stats.deleted}`);
+    logs.push(`Skipped: ${stats.skipped}`);
+    logs.push(`Errors:  ${stats.errors}`);
+    logs.push(`-----------------------------------`);
+    return { stats, logs };
+  },
+  async push() {
+    const stats = { created: 0, updated: 0, skipped: 0, errors: 0 };
+    const checksums = loadChecksums();
+    const componentSchemas = getComponentSchemas();
+    const logs = [];
+    const contentTypes2 = Object.keys(strapi2.contentTypes).filter((uid) => uid.startsWith("api::")).map((uid) => strapi2.contentTypes[uid]);
+    for (const contentType of contentTypes2) {
+      const typeName = contentType.collectionName || contentType.info.pluralName;
+      const uid = contentType.uid;
+      const typeDir = path.join(SERIALIZATION_DIR, typeName);
+      if (!fs.existsSync(typeDir)) continue;
+      const files = fs.readdirSync(typeDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+      if (files.length > 0) logs.push(`
+--- Processing ${typeName} ---`);
+      for (const file of files) {
+        const filePath = path.join(typeDir, file);
+        const rawContent = fs.readFileSync(filePath, "utf8");
+        const data = yaml.load(rawContent);
+        const relPath = path.join(typeName, file).replace(/\\/g, "/");
+        const currentHash = getHash(rawContent);
+        if (checksums[relPath] === currentHash) {
+          stats.skipped++;
+          logs.push(`[SKIPPED] ${file}`);
+          continue;
+        }
+        try {
+          let attributes = { ...data };
+          if (data.attributes) Object.assign(attributes, data.attributes);
+          const sanitizedData = recursiveSanitize(attributes, contentType.attributes, componentSchemas);
+          let targetId = data.documentId;
+          if (!targetId && contentType.attributes.slug && data.slug) {
+            const existing = await strapi2.documents(uid).findFirst({ filters: { slug: data.slug } });
+            if (existing) targetId = existing.documentId;
+          }
+          if (contentType.kind === "singleType") {
+            const existing = await strapi2.documents(uid).findFirst();
+            if (existing) targetId = existing.documentId;
+          }
+          if (targetId) {
+            await strapi2.documents(uid).update({ documentId: targetId, data: sanitizedData });
+            stats.updated++;
+            logs.push(`[UPDATED] ${file}`);
+          } else {
+            await strapi2.documents(uid).create({ data: sanitizedData });
+            stats.created++;
+            logs.push(`[CREATED] ${file}`);
+          }
+          checksums[relPath] = currentHash;
+        } catch (e) {
+          stats.errors++;
+          logs.push(`[ERROR] ${file}: ${e.message}`);
+          strapi2.log.error(`[Serialization] Push Error ${file}: ${e.message}`);
+        }
+      }
+    }
+    saveChecksums(checksums);
+    logs.push(`
+-----------------------------------`);
+    logs.push(`PUSH SUMMARY`);
+    logs.push(`-----------------------------------`);
+    logs.push(`Created: ${stats.created}`);
+    logs.push(`Updated: ${stats.updated}`);
+    logs.push(`Skipped: ${stats.skipped}`);
+    logs.push(`Errors:  ${stats.errors}`);
+    logs.push(`-----------------------------------`);
+    return { stats, logs };
+  }
+});
+const services = {
+  service,
+  serialization
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "version": "0.0.0",
+  "keywords": [],
+  "type": "commonjs",
+  "exports": {
+    "./package.json": "./package.json",
+    "./strapi-admin": {
+      "types": "./dist/admin/src/index.d.ts",
+      "source": "./admin/src/index.ts",
+      "import": "./dist/admin/index.mjs",
+      "require": "./dist/admin/index.js",
+      "default": "./dist/admin/index.js"
+    },
+    "./strapi-server": {
+      "types": "./dist/server/src/index.d.ts",
+      "source": "./server/src/index.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "strapi-plugin build",
+    "watch": "strapi-plugin watch",
+    "watch:link": "strapi-plugin watch:link",
+    "verify": "strapi-plugin verify",
+    "test:ts:front": "run -T tsc -p admin/tsconfig.json",
+    "test:ts:back": "run -T tsc -p server/tsconfig.json"
+  },
+  "dependencies": {
+    "@strapi/design-system": "^2.0.0-rc.30",
+    "@strapi/icons": "^2.0.0-rc.30",
+    "@types/js-yaml": "^4.0.9",
+    "js-yaml": "^4.1.1",
+    "react-intl": "^8.0.10"
+  },
+  "devDependencies": {
+    "@strapi/sdk-plugin": "^5.4.0",
+    "@strapi/strapi": "^5.33.1",
+    "@strapi/typescript-utils": "^5.33.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "prettier": "^3.7.4",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.30.2",
+    "styled-components": "^6.1.19",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@strapi/sdk-plugin": "^5.4.0",
+    "@strapi/strapi": "^5.33.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.30.2",
+    "styled-components": "^6.1.19"
+  },
+  "strapi": {
+    "kind": "plugin",
+    "name": "content-serialization",
+    "displayName": "Content CLI",
+    "description": ""
+  },
+  "name": "content-serialization",
+  "description": "",
+  "license": "MIT",
+  "author": "Jaydeep <jaydeepkotak10@gmail.com>"
+}