Plugin System

# Install a plugin globally
npm install -g datachonk-plugin-snowflake-optimizer

# Or add to your project
npm install datachonk-plugin-custom-templates

# Verify installation
datachonk plugins

module.exports = {
  name: 'my-custom-plugin',
  version: '1.0.0',
  type: 'template',
  
  // Called when plugin loads
  init(context) {
    console.log('Plugin initialized');
  },
  
  // Register templates, parsers, etc.
  register(registry) {
    registry.addTemplate('custom-staging', {
      name: 'Custom Staging Model',
      generate: (config) => generateStagingModel(config)
    });
  }
};

import { DataChonkPlugin, ParserContext } from 'datachonk';

interface MacroDefinition {
  name: string;
  pattern: RegExp;
  transform: (match: RegExpMatchArray) => string;
}

const customMacros: MacroDefinition[] = [
  {
    name: 'safe_divide',
    pattern: /\{\{ safe_divide\(([^,]+),\s*([^)]+)\) \}\}/g,
    transform: (match) => `NULLIF(${match[1]}, 0) / ${match[2]}`
  },
  {
    name: 'date_spine',
    pattern: /\{\{ date_spine\(([^)]+)\) \}\}/g,
    transform: (match) => `/* date_spine for ${match[1]} */`
  }
];

const plugin: DataChonkPlugin = {
  name: 'custom-macros',
  version: '1.0.0',
  type: 'parser',
  
  init(context) {
    context.logger.info('Custom macros plugin loaded');
  },
  
  register(registry) {
    registry.addParser('macro-expander', {
      priority: 10, // Run early in parsing pipeline
      
      parse(sql: string, ctx: ParserContext) {
        let result = sql;
        
        for (const macro of customMacros) {
          result = result.replace(macro.pattern, (match, ...groups) => {
            ctx.logger.debug(`Expanding macro: ${macro.name}`);
            return macro.transform([match, ...groups]);
          });
        }
        
        return result;
      }
    });
  }
};

export default plugin;

{
  "name": "datachonk-plugin-custom-macros",
  "version": "1.0.0",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "keywords": ["datachonk-plugin", "dbt", "macros"],
  "peerDependencies": {
    "datachonk": "^1.0.0"
  },
  "datachonk": {
    "type": "parser",
    "minVersion": "1.0.0"
  }
}

import { DataChonkPlugin, TemplateContext } from 'datachonk';

const plugin: DataChonkPlugin = {
  name: 'company-templates',
  version: '1.0.0',
  type: 'template',
  
  register(registry) {
    // Custom staging template
    registry.addTemplate('company-staging', {
      name: 'Company Staging Model',
      description: 'Staging model with company conventions',
      category: 'staging',
      
      generate(ctx: TemplateContext) {
        const { source, columns } = ctx;
        
        return `-- Company Staging Model
-- Source: ${source.name}
-- Generated: ${new Date().toISOString()}
-- Owner: ${ctx.config.owner || 'data-team'}

{{ config(
    materialized='view',
    tags=['staging', '${source.schema}']
) }}

with source as (
    select * from {{ source('${source.schema}', '${source.table}') }}
),

renamed as (
    select
        -- Primary Key
        ${columns.filter(c => c.isPrimaryKey).map(c => 
          `${c.name} as ${toSnakeCase(c.name)}`
        ).join(',\n        ')},
        
        -- Attributes
        ${columns.filter(c => !c.isPrimaryKey).map(c => 
          `${c.name} as ${toSnakeCase(c.name)}`
        ).join(',\n        ')},
        
        -- Metadata
        current_timestamp() as _loaded_at,
        '{{ invocation_id }}' as _batch_id
    from source
)

select * from renamed`;
      }
    });
    
    // Custom dimension template
    registry.addTemplate('company-dimension', {
      name: 'Company Dimension',
      description: 'SCD Type 2 dimension with company conventions',
      category: 'entity',
      
      generate(ctx: TemplateContext) {
        // ... dimension template logic
      }
    });
  }
};

export default plugin;

{
  "plugins": {
    "enabled": [
      "datachonk-plugin-snowflake-optimizer",
      "datachonk-plugin-custom-macros",
      "./plugins/company-templates"
    ],
    "disabled": [
      "datachonk-plugin-deprecated"
    ],
    "config": {
      "datachonk-plugin-snowflake-optimizer": {
        "clusteringEnabled": true,
        "defaultWarehouse": "COMPUTE_WH"
      },
      "datachonk-plugin-custom-macros": {
        "strictMode": true
      }
    }
  }
}