@dani-builder/strapi-plugin-builder 0.1.0

package/bin/sync.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ─── Helpers ──────────────────────────────────────────────
+
+function hash(content) {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const opts = {
+    command: null,
+    dryRun: false,
+    force: false,
+    only: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--dry-run') {
+      opts.dryRun = true;
+    } else if (arg === '--force') {
+      opts.force = true;
+    } else if (arg === '--only' && args[i + 1]) {
+      opts.only = args[++i].split(',').map((s) => s.trim());
+    } else if (!arg.startsWith('-')) {
+      opts.command = arg;
+    }
+  }
+
+  return opts;
+}
+
+// ─── Colors (minimal, no dependency) ─────────────────────
+
+const c = {
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+};
+
+// ─── Strapi Boilerplate Generation ───────────────────────
+
+function generateBoilerplate(ctName, uid, targetApiDir, opts) {
+  const files = [
+    {
+      rel: `routes/${ctName}.ts`,
+      content: `import { factories } from '@strapi/strapi';\nexport default factories.createCoreRouter('${uid}');\n`,
+    },
+    {
+      rel: `controllers/${ctName}.ts`,
+      content: `import { factories } from '@strapi/strapi';\nexport default factories.createCoreController('${uid}');\n`,
+    },
+    {
+      rel: `services/${ctName}.ts`,
+      content: `import { factories } from '@strapi/strapi';\nexport default factories.createCoreService('${uid}');\n`,
+    },
+  ];
+
+  const created = [];
+  for (const file of files) {
+    const filePath = path.join(targetApiDir, file.rel);
+    if (!fs.existsSync(filePath)) {
+      if (!opts.dryRun) {
+        ensureDir(path.dirname(filePath));
+        fs.writeFileSync(filePath, file.content, 'utf-8');
+      }
+      created.push(file.rel);
+    }
+  }
+  return created;
+}
+
+function extractUid(schemaPath) {
+  try {
+    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf-8'));
+    const info = schema.info || {};
+    const singularName = info.singularName;
+    if (singularName) {
+      return `api::${singularName}.${singularName}`;
+    }
+  } catch {
+    // fallback below
+  }
+  // Fallback: derive from path (api/{name}/content-types/{name}/schema.json)
+  const parts = schemaPath.split(path.sep);
+  const apiIdx = parts.indexOf('api');
+  if (apiIdx >= 0 && parts[apiIdx + 1]) {
+    const name = parts[apiIdx + 1];
+    return `api::${name}.${name}`;
+  }
+  return null;
+}
+
+// ─── Sync Logic ──────────────────────────────────────────
+
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+      // Look for Strapi project indicators
+      if (
+        pkg.dependencies?.['@strapi/strapi'] ||
+        pkg.devDependencies?.['@strapi/strapi'] ||
+        fs.existsSync(path.join(dir, 'config', 'database.js')) ||
+        fs.existsSync(path.join(dir, 'config', 'database.ts'))
+      ) {
+        return dir;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function findPluginSchemasDir() {
+  // When installed as a dependency, schemas/ is at the package root
+  const packageRoot = path.resolve(__dirname, '..');
+  const schemasDir = path.join(packageRoot, 'schemas');
+  if (fs.existsSync(schemasDir)) {
+    return schemasDir;
+  }
+  throw new Error('Could not find plugin schemas directory');
+}
+
+function sync(opts) {
+  const projectRoot = findProjectRoot();
+  const schemasDir = findPluginSchemasDir();
+  const manifestPath = path.join(schemasDir, 'manifest.json');
+  const localManifestPath = path.join(projectRoot, '.daniworks-sync-manifest.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    console.error(c.red('Error: manifest.json not found in plugin schemas directory'));
+    process.exit(1);
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+  const localManifest = fs.existsSync(localManifestPath)
+    ? JSON.parse(fs.readFileSync(localManifestPath, 'utf-8'))
+    : { version: '0.0.0', schemas: {} };
+
+  const srcDir = path.join(projectRoot, 'src');
+  const results = { synced: [], skipped: [], created: [], boilerplate: [] };
+
+  console.log('');
+  console.log(c.bold(`  @dani-builder/strapi-plugin-builder sync v${manifest.version}`));
+  console.log(c.dim(`  Project: ${projectRoot}`));
+  console.log(c.dim(`  Schemas: ${schemasDir}`));
+  if (opts.dryRun) {
+    console.log(c.yellow('  Mode: DRY RUN (no files will be modified)'));
+  }
+  console.log('');
+
+  for (const [relativePath, sourceHash] of Object.entries(manifest.schemas)) {
+    const ctName = relativePath.split('/')[1]; // e.g. "page"
+
+    // Filter by --only
+    if (opts.only && !opts.only.includes(ctName)) {
+      continue;
+    }
+
+    const sourcePath = path.join(schemasDir, relativePath);
+    const targetPath = path.join(srcDir, relativePath);
+
+    if (!fs.existsSync(sourcePath)) {
+      console.log(c.red(`  ✗ ${relativePath} — source file missing`));
+      continue;
+    }
+
+    const sourceContent = fs.readFileSync(sourcePath, 'utf-8');
+
+    // Check if target already exists
+    if (fs.existsSync(targetPath)) {
+      const targetContent = fs.readFileSync(targetPath, 'utf-8');
+      const targetHash = hash(targetContent);
+
+      // Compare against the last synced version (from local manifest)
+      const lastSyncedHash = localManifest.schemas[relativePath];
+
+      if (lastSyncedHash && targetHash !== lastSyncedHash && !opts.force) {
+        // Local modification detected
+        console.log(
+          c.yellow(`  ⚠ ${relativePath}`) + c.dim(' — local modifications detected, skipping')
+        );
+        console.log(c.dim(`    Use --force to overwrite`));
+        results.skipped.push(relativePath);
+        continue;
+      }
+
+      if (targetHash === sourceHash) {
+        // Already up to date
+        console.log(c.dim(`  ✓ ${relativePath} — already up to date`));
+        continue;
+      }
+
+      // Update needed
+      if (!opts.dryRun) {
+        fs.writeFileSync(targetPath, sourceContent, 'utf-8');
+      }
+      console.log(c.green(`  ↑ ${relativePath}`) + c.dim(' — updated'));
+      results.synced.push(relativePath);
+    } else {
+      // New file
+      if (!opts.dryRun) {
+        ensureDir(path.dirname(targetPath));
+        fs.writeFileSync(targetPath, sourceContent, 'utf-8');
+      }
+      console.log(c.cyan(`  + ${relativePath}`) + c.dim(' — created'));
+      results.created.push(relativePath);
+    }
+  }
+
+  // Generate boilerplate (routes/controllers/services) for each CT
+  const processedCts = new Set();
+  for (const relativePath of Object.keys(manifest.schemas)) {
+    const ctName = relativePath.split('/')[1];
+    if (processedCts.has(ctName)) continue;
+    if (opts.only && !opts.only.includes(ctName)) continue;
+    processedCts.add(ctName);
+
+    const targetApiDir = path.join(srcDir, 'api', ctName);
+    const schemaFile = path.join(targetApiDir, 'content-types', ctName, 'schema.json');
+    const uid = extractUid(schemaFile);
+    if (!uid) continue;
+
+    const created = generateBoilerplate(ctName, uid, targetApiDir, opts);
+    for (const file of created) {
+      console.log(c.cyan(`  + api/${ctName}/${file}`) + c.dim(' — generated'));
+      results.boilerplate.push(`api/${ctName}/${file}`);
+    }
+  }
+
+  // Update local manifest (unless dry run)
+  if (!opts.dryRun) {
+    const newLocalManifest = {
+      version: manifest.version,
+      schemas: { ...manifest.schemas },
+    };
+    fs.writeFileSync(localManifestPath, JSON.stringify(newLocalManifest, null, 2) + '\n');
+  }
+
+  // Summary
+  console.log('');
+  console.log(c.bold('  Summary:'));
+  console.log(`    Created: ${c.cyan(results.created.length)}`);
+  console.log(`    Updated: ${c.green(results.synced.length)}`);
+  console.log(`    Skipped: ${c.yellow(results.skipped.length)}`);
+  console.log(`    Boilerplate: ${c.cyan(results.boilerplate.length)}`);
+  console.log('');
+
+  if (opts.dryRun) {
+    console.log(c.yellow('  This was a dry run. No files were modified.'));
+    console.log(c.dim('  Run without --dry-run to apply changes.'));
+    console.log('');
+  }
+}
+
+// ─── Help ────────────────────────────────────────────────
+
+function showHelp() {
+  console.log(`
+  ${c.bold('@dani-builder/strapi-plugin-builder')} — Content Type sync CLI
+
+  ${c.bold('Usage:')}
+    npx @dani-builder/strapi-plugin-builder sync [options]
+
+  ${c.bold('Commands:')}
+    sync          Synchronize content type schemas to your Strapi project
+
+  ${c.bold('Options:')}
+    --dry-run     Show what would change without modifying files
+    --force       Overwrite local modifications
+    --only <names> Sync only specific content types (comma-separated)
+                  Example: --only page,article,global
+
+  ${c.bold('Examples:')}
+    npx @dani-builder/strapi-plugin-builder sync
+    npx @dani-builder/strapi-plugin-builder sync --dry-run
+    npx @dani-builder/strapi-plugin-builder sync --force
+    npx @dani-builder/strapi-plugin-builder sync --only page,global
+`);
+}
+
+// ─── Main ────────────────────────────────────────────────
+
+function main() {
+  const opts = parseArgs(process.argv);
+
+  if (!opts.command || opts.command === 'help' || opts.command === '--help') {
+    showHelp();
+    return;
+  }
+
+  if (opts.command === 'sync') {
+    sync(opts);
+    return;
+  }
+
+  console.error(c.red(`Unknown command: ${opts.command}`));
+  showHelp();
+  process.exit(1);
+}
+
+main();

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,6 @@
+import type { Core } from '@strapi/strapi';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default bootstrap;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/server/src/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../server/src/bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE3C,QAAA,MAAM,SAAS,GAAI,YAAY;IAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAA;CAAE,SAGrD,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/server/src/bootstrap.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bootstrap = ({ strapi }) => {
+    // Initialize populate service with core block definitions
+    strapi.plugin('builder').service('populate').buildBlocksPopulate();
+};
+exports.default = bootstrap;
+//# sourceMappingURL=bootstrap.js.map

package/dist/server/src/bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../../server/src/bootstrap.ts"],"names":[],"mappings":";;AAEA,MAAM,SAAS,GAAG,CAAC,EAAE,MAAM,EAA2B,EAAE,EAAE;IACxD,0DAA0D;IAC1D,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,mBAAmB,EAAE,CAAC;AACrE,CAAC,CAAC;AAEF,kBAAe,SAAS,CAAC"}

package/dist/server/src/components/blocks/bento-grid.json

@@ -0,0 +1,29 @@
+{
+  "collectionName": "components_blocks_bento_grids",
+  "info": {
+    "displayName": "Bento Grid",
+    "icon": "grid",
+    "description": "Asymmetric grid layout with per-item span control"
+  },
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "columns": {
+      "type": "integer",
+      "min": 2,
+      "max": 4,
+      "default": 3
+    },
+    "items": {
+      "type": "component",
+      "component": "shared.bento-item",
+      "repeatable": true
+    }
+  }
+}

package/dist/server/src/components/blocks/content.json

@@ -0,0 +1,23 @@
+{
+  "collectionName": "components_blocks_contents",
+  "info": {
+    "displayName": "Content",
+    "icon": "feather",
+    "description": "Rich text content block using Strapi Blocks editor"
+  },
+  "attributes": {
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "variant": {
+      "type": "enumeration",
+      "enum": ["prose", "wide", "full-width"]
+    },
+    "body": {
+      "type": "blocks",
+      "required": true
+    }
+  }
+}

package/dist/server/src/components/blocks/cta.json

@@ -0,0 +1,37 @@
+{
+  "collectionName": "components_blocks_ctas",
+  "info": {
+    "displayName": "CTA",
+    "icon": "cursor",
+    "description": "Call-to-Action block with media and action links"
+  },
+  "attributes": {
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "variant": {
+      "type": "enumeration",
+      "enum": ["inline-spread", "inline-centered", "inline-stacked", "card-stacked", "card-centered", "card-horizontal"]
+    },
+    "ctaMedia": {
+      "type": "media",
+      "multiple": false,
+      "allowedTypes": ["images", "videos"]
+    },
+    "ctaText": {
+      "type": "text"
+    },
+    "ctaLink": {
+      "type": "component",
+      "component": "shared.link",
+      "repeatable": false
+    },
+    "secondaryLink": {
+      "type": "component",
+      "component": "shared.link",
+      "repeatable": false
+    }
+  }
+}

package/dist/server/src/components/blocks/faq.json

@@ -0,0 +1,20 @@
+{
+  "collectionName": "components_blocks_faqs",
+  "info": {
+    "displayName": "FAQ",
+    "icon": "question",
+    "description": "FAQ list block linked to FAQ content type via relation"
+  },
+  "attributes": {
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "items": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::faq.faq"
+    }
+  }
+}

package/dist/server/src/components/blocks/features.json

@@ -0,0 +1,32 @@
+{
+  "collectionName": "components_blocks_features",
+  "info": {
+    "displayName": "Features",
+    "icon": "apps",
+    "description": "Feature/service showcase with icon+text items"
+  },
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "variant": {
+      "type": "enumeration",
+      "enum": ["simple-grid", "dual-column", "media-aside", "media-aside-compact"]
+    },
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "media": {
+      "type": "media",
+      "multiple": false,
+      "allowedTypes": ["images"]
+    },
+    "items": {
+      "type": "component",
+      "component": "shared.feature-item",
+      "repeatable": true
+    }
+  }
+}

package/dist/server/src/components/blocks/hero.json

@@ -0,0 +1,42 @@
+{
+  "collectionName": "components_blocks_heroes",
+  "info": {
+    "displayName": "Hero",
+    "icon": "picture",
+    "description": "Hero banner with media, CTA links, and layout variants"
+  },
+  "attributes": {
+    "variant": {
+      "type": "enumeration",
+      "enum": ["side-by-side", "media-extending", "fullscreen-media", "stacked-media"]
+    },
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "heroMedia": {
+      "type": "media",
+      "multiple": false,
+      "allowedTypes": ["images", "videos"]
+    },
+    "ctaText": {
+      "type": "text"
+    },
+    "ctaLink": {
+      "type": "component",
+      "component": "shared.link",
+      "repeatable": false
+    },
+    "secondaryLink": {
+      "type": "component",
+      "component": "shared.link",
+      "repeatable": false
+    },
+    "headerMode": {
+      "type": "enumeration",
+      "enum": ["none", "transparent-black", "transparent-white"],
+      "default": "none"
+    }
+  }
+}

package/dist/server/src/components/blocks/highlights.json

@@ -0,0 +1,32 @@
+{
+  "collectionName": "components_blocks_highlights",
+  "info": {
+    "displayName": "Highlights",
+    "icon": "star",
+    "description": "Highlight/feature showcase with media+text items"
+  },
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "variant": {
+      "type": "enumeration",
+      "enum": ["dual-column", "triple-column", "alternating"]
+    },
+    "media": {
+      "type": "media",
+      "multiple": false,
+      "allowedTypes": ["images", "videos"]
+    },
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "items": {
+      "type": "component",
+      "component": "shared.highlight-item",
+      "repeatable": true
+    }
+  }
+}

package/dist/server/src/components/blocks/inquiry-form.json

@@ -0,0 +1,18 @@
+{
+  "collectionName": "components_blocks_inquiry_forms",
+  "info": {
+    "displayName": "Inquiry Form",
+    "icon": "envelop",
+    "description": "Contact form block that submits to Inquiry content type"
+  },
+  "attributes": {
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "successMessage": {
+      "type": "text"
+    }
+  }
+}

package/dist/server/src/components/blocks/logo-cloud.json

@@ -0,0 +1,27 @@
+{
+  "collectionName": "components_blocks_logo_clouds",
+  "info": {
+    "displayName": "Logo Cloud",
+    "icon": "picture",
+    "description": "Client/partner logo showcase block"
+  },
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "variant": {
+      "type": "enumeration",
+      "enum": ["inline", "grid", "split"]
+    },
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "items": {
+      "type": "component",
+      "component": "shared.logo-item",
+      "repeatable": true
+    }
+  }
+}

package/dist/server/src/components/blocks/pricing.json

@@ -0,0 +1,27 @@
+{
+  "collectionName": "components_blocks_pricings",
+  "info": {
+    "displayName": "Pricing",
+    "icon": "priceTag",
+    "description": "Pricing plans/tiers comparison block"
+  },
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "variant": {
+      "type": "enumeration",
+      "enum": ["two-column", "three-column", "single", "with-comparison"]
+    },
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "items": {
+      "type": "component",
+      "component": "shared.pricing-tier",
+      "repeatable": true
+    }
+  }
+}

package/dist/server/src/components/blocks/slider.json

@@ -0,0 +1,27 @@
+{
+  "collectionName": "components_blocks_sliders",
+  "info": {
+    "displayName": "Slider",
+    "icon": "slideshow",
+    "description": "Slider/carousel block with media+text items"
+  },
+  "attributes": {
+    "name": {
+      "type": "string"
+    },
+    "variant": {
+      "type": "enumeration",
+      "enum": ["cover-flow", "card-slider"]
+    },
+    "section": {
+      "type": "component",
+      "component": "elements.section",
+      "repeatable": false
+    },
+    "items": {
+      "type": "component",
+      "component": "shared.slider-item",
+      "repeatable": true
+    }
+  }
+}