blok0 0.1.0 → 0.1.1

package/src/registry/index.ts

@@ -0,0 +1,244 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+export interface BlockSource {
+  url: string;
+  id: number;
+}
+
+export interface BlockEntry {
+  id: number;
+  name: string;
+  slug: string;
+  dir: string;
+  configPath: string;
+  componentPath: string;
+  source: BlockSource & {
+    fetchedAt: string;
+  };
+  checksums: {
+    [filename: string]: string;
+  };
+}
+
+export interface RegistryData {
+  version: string;
+  blocks: {
+    [slug: string]: BlockEntry;
+  };
+}
+
+const REGISTRY_FILE = 'blok0-registry.json';
+const REGISTRY_VERSION = '1.0';
+
+/**
+ * Get registry file path
+ */
+function getRegistryPath(): string {
+  return path.join(process.cwd(), REGISTRY_FILE);
+}
+
+/**
+ * Load registry from file
+ */
+export function loadRegistry(): RegistryData {
+  const registryPath = getRegistryPath();
+
+  if (!fs.existsSync(registryPath)) {
+    return {
+      version: REGISTRY_VERSION,
+      blocks: {}
+    };
+  }
+
+  try {
+    const data = fs.readFileSync(registryPath, 'utf-8');
+    const registry = JSON.parse(data);
+
+    // Validate registry structure
+    if (!registry.version || !registry.blocks) {
+      throw new Error('Invalid registry structure');
+    }
+
+    return registry;
+  } catch (error) {
+    throw new Error(`Failed to load registry: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Save registry to file
+ */
+export function saveRegistry(registry: RegistryData): void {
+  const registryPath = getRegistryPath();
+
+  try {
+    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+  } catch (error) {
+    throw new Error(`Failed to save registry: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Check if block slug already exists in registry
+ */
+export function isBlockRegistered(slug: string): boolean {
+  const registry = loadRegistry();
+  return slug in registry.blocks;
+}
+
+/**
+ * Get block entry by slug
+ */
+export function getBlockEntry(slug: string): BlockEntry | null {
+  const registry = loadRegistry();
+  return registry.blocks[slug] || null;
+}
+
+/**
+ * Add block to registry
+ */
+export function addBlockToRegistry(entry: BlockEntry): void {
+  const registry = loadRegistry();
+
+  if (entry.slug in registry.blocks) {
+    throw new Error(`Block with slug '${entry.slug}' is already registered`);
+  }
+
+  registry.blocks[entry.slug] = entry;
+  saveRegistry(registry);
+}
+
+/**
+ * Remove block from registry
+ */
+export function removeBlockFromRegistry(slug: string): void {
+  const registry = loadRegistry();
+
+  if (!(slug in registry.blocks)) {
+    throw new Error(`Block with slug '${slug}' is not registered`);
+  }
+
+  delete registry.blocks[slug];
+  saveRegistry(registry);
+}
+
+/**
+ * Update block checksums
+ */
+export function updateBlockChecksums(slug: string, checksums: { [filename: string]: string }): void {
+  const registry = loadRegistry();
+
+  if (!(slug in registry.blocks)) {
+    throw new Error(`Block with slug '${slug}' is not registered`);
+  }
+
+  registry.blocks[slug].checksums = checksums;
+  saveRegistry(registry);
+}
+
+/**
+ * Calculate file checksum
+ */
+export function calculateChecksum(filePath: string): string {
+  const fileBuffer = fs.readFileSync(filePath);
+  const hashSum = crypto.createHash('sha256');
+  hashSum.update(fileBuffer);
+  return hashSum.digest('hex');
+}
+
+/**
+ * Calculate checksums for all files in a directory
+ */
+export function calculateDirectoryChecksums(dirPath: string): { [filename: string]: string } {
+  const checksums: { [filename: string]: string } = {};
+
+  function walkDirectory(dir: string): void {
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      const stat = fs.statSync(filePath);
+
+      if (stat.isDirectory()) {
+        walkDirectory(filePath);
+      } else {
+        const relativePath = path.relative(dirPath, filePath);
+        checksums[relativePath] = calculateChecksum(filePath);
+      }
+    }
+  }
+
+  walkDirectory(dirPath);
+  return checksums;
+}
+
+/**
+ * Validate registry integrity
+ */
+export function validateRegistry(): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  try {
+    const registry = loadRegistry();
+
+    for (const [slug, entry] of Object.entries(registry.blocks)) {
+      // Check if block directory exists
+      if (!fs.existsSync(entry.dir)) {
+        errors.push(`Block '${slug}': directory '${entry.dir}' does not exist`);
+        continue;
+      }
+
+      // Check if config file exists
+      if (!fs.existsSync(entry.configPath)) {
+        errors.push(`Block '${slug}': config file '${entry.configPath}' does not exist`);
+      }
+
+      // Check if component file exists
+      if (!fs.existsSync(entry.componentPath)) {
+        errors.push(`Block '${slug}': component file '${entry.componentPath}' does not exist`);
+      }
+
+      // Validate checksums if they exist
+      if (entry.checksums) {
+        for (const [file, expectedChecksum] of Object.entries(entry.checksums)) {
+          const filePath = path.join(entry.dir, file);
+          if (fs.existsSync(filePath)) {
+            const actualChecksum = calculateChecksum(filePath);
+            if (actualChecksum !== expectedChecksum) {
+              errors.push(`Block '${slug}': checksum mismatch for '${file}'`);
+            }
+          } else {
+            errors.push(`Block '${slug}': file '${file}' referenced in checksums does not exist`);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    errors.push(`Registry validation failed: ${(error as Error).message}`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Create empty registry for new projects
+ */
+export function createEmptyRegistry(): void {
+  const registryPath = getRegistryPath();
+
+  if (fs.existsSync(registryPath)) {
+    throw new Error('Registry already exists');
+  }
+
+  const emptyRegistry: RegistryData = {
+    version: REGISTRY_VERSION,
+    blocks: {}
+  };
+
+  saveRegistry(emptyRegistry);
+}

package/test-ast.js

@@ -0,0 +1,150 @@
+const { updatePageCollectionConfig, updateRenderBlocksComponent, findPagesCollection, extractComponentName } = require('./dist/ast/index.js');
+const { slugToIdentifier } = require('./dist/blocks/index.js');
+const fs = require('fs');
+
+// Test case: Add editorial--carousel block
+// Simulates: blok0 add-block https://www.blok0.xyz/api/cli/sections/editorial--carousel
+
+console.log('🧪 Testing Editorial Carousel Block Addition');
+console.log('==========================================');
+console.log('');
+
+// Change to Payload project directory
+const payloadProjectPath = '../newcms';
+console.log(`📁 Changing to Payload project directory: ${payloadProjectPath}`);
+try {
+  process.chdir(payloadProjectPath);
+  console.log('✅ Successfully changed directory');
+} catch (error) {
+  console.log('❌ Failed to change directory:', error.message);
+  process.exit(1);
+}
+
+console.log('');
+console.log('🔍 Finding Pages collection...');
+const pagesPath = findPagesCollection();
+console.log('Pages collection path:', pagesPath);
+
+if (pagesPath) {
+  console.log('');
+  console.log('🧪 Testing AST update for editorial--carousel block...');
+
+  const blockSlug = 'editorial--carousel';
+  const blockIdentifier = slugToIdentifier(blockSlug);
+  const blockConfigPath = `@/blocks/${blockSlug}/config`;
+
+  console.log(`Block slug: ${blockSlug}`);
+  console.log(`Block identifier: ${blockIdentifier}`);
+  console.log(`Config path: ${blockConfigPath}`);
+  console.log('');
+
+  // Read file before modification
+  const originalContent = fs.readFileSync(pagesPath, 'utf-8');
+  const hasOriginalImport = originalContent.includes(`import { ${blockIdentifier} } from '${blockConfigPath}'`);
+  const hasOriginalBlock = originalContent.includes(blockIdentifier);
+
+  console.log('📋 Before modification:');
+  console.log(`  - Import present: ${hasOriginalImport}`);
+  console.log(`  - Block in array: ${hasOriginalBlock}`);
+  console.log('');
+
+  try {
+    updatePageCollectionConfig(pagesPath, blockConfigPath, blockIdentifier);
+
+    // Read file after modification
+    const updatedContent = fs.readFileSync(pagesPath, 'utf-8');
+    const hasUpdatedImport = updatedContent.includes(`import { ${blockIdentifier} } from '${blockConfigPath}'`);
+    const hasUpdatedBlock = updatedContent.includes(blockIdentifier);
+
+    console.log('📋 After Pages modification:');
+    console.log(`  - Import present: ${hasUpdatedImport}`);
+    console.log(`  - Block in array: ${hasUpdatedBlock}`);
+    console.log('');
+
+    if (hasUpdatedImport && hasUpdatedBlock) {
+      console.log('✅ Pages collection update successful!');
+    } else {
+      console.log('⚠️  Pages collection update issues:');
+      if (!hasUpdatedImport) console.log('  - ❌ Import was not added');
+      if (!hasUpdatedBlock) console.log('  - ❌ Block was not added to array');
+      process.exit(1);
+    }
+
+    // Now test RenderBlocks update
+    console.log('🧪 Testing RenderBlocks component update...');
+
+    const renderBlocksPath = '../newcms/src/blocks/RenderBlocks.tsx';
+    const componentPath = `./${blockSlug}/Component`;
+
+    // Check if the component file exists (it won't for editorial-carousel in test)
+    const fullComponentPath = require('path').resolve(componentPath.replace('./', 'src/blocks/') + '.tsx');
+    const componentExists = fs.existsSync(fullComponentPath);
+
+    if (componentExists) {
+      console.log('📄 Component file exists, testing full RenderBlocks update...');
+
+      // Extract the actual component name
+      const actualComponentName = extractComponentName(fullComponentPath);
+      const blockTypeKey = 'editorialCarousel';
+
+      console.log(`Extracted component name: ${actualComponentName}`);
+      console.log(`Block type key: ${blockTypeKey}`);
+
+      // Read RenderBlocks before modification
+      const originalRenderBlocksContent = fs.readFileSync(renderBlocksPath, 'utf-8');
+      const hasOriginalComponentImport = originalRenderBlocksContent.includes(`import { ${actualComponentName} } from '${componentPath}'`);
+      const hasOriginalBlockComponent = originalRenderBlocksContent.includes(`'${blockTypeKey}': ${actualComponentName}`);
+
+      console.log('📋 RenderBlocks before modification:');
+      console.log(`  - Component import present: ${hasOriginalComponentImport}`);
+      console.log(`  - Block component mapping present: ${hasOriginalBlockComponent}`);
+      console.log('');
+
+      updateRenderBlocksComponent(renderBlocksPath, blockSlug, componentPath);
+
+      // Read RenderBlocks after modification
+      const updatedRenderBlocksContent = fs.readFileSync(renderBlocksPath, 'utf-8');
+      const hasUpdatedComponentImport = updatedRenderBlocksContent.includes(`import { ${actualComponentName} } from '${componentPath}'`);
+      const hasUpdatedBlockComponent = updatedRenderBlocksContent.includes(`'${blockTypeKey}': ${actualComponentName}`);
+
+      console.log('📋 RenderBlocks after modification:');
+      console.log(`  - Component import present: ${hasUpdatedComponentImport}`);
+      console.log(`  - Block component mapping present: ${hasUpdatedBlockComponent}`);
+      console.log('');
+
+      if (hasUpdatedComponentImport && hasUpdatedBlockComponent) {
+        console.log('✅ RenderBlocks update successful! Component and mapping added.');
+        console.log('');
+        console.log('🎉 Complete test passed! Pages collection and RenderBlocks updates work correctly.');
+      } else {
+        console.log('⚠️  RenderBlocks update issues:');
+        if (!hasUpdatedComponentImport) console.log('  - ❌ Component import was not added');
+        if (!hasUpdatedBlockComponent) console.log('  - ❌ Block component mapping was not added');
+        console.log('');
+        console.log('💥 Test failed! RenderBlocks implementation has issues.');
+        process.exit(1);
+      }
+    } else {
+      console.log('📄 Component file does not exist (expected for test), testing error handling...');
+
+      try {
+        updateRenderBlocksComponent(renderBlocksPath, blockSlug, componentPath);
+        console.log('❌ Expected error but function succeeded unexpectedly');
+        process.exit(1);
+      } catch (error) {
+        console.log('✅ Function correctly failed with error:', error.message);
+        console.log('');
+        console.log('🎉 Test passed! Function properly handles missing component files.');
+      }
+    }
+  } catch (error) {
+    console.log('❌ AST update failed:', error.message);
+    console.log('');
+    console.log('💥 Test failed! The bug may not be fully fixed.');
+    process.exit(1);
+  }
+} else {
+  console.log('❌ Could not find Pages collection in Payload project');
+  console.log('Make sure you are running this from a valid Payload CMS project directory.');
+  process.exit(1);
+}

package/tsconfig.json

@@ -1,16 +1,16 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "src/templates/**"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "src/templates/**"]
+}