modscape 2.0.2 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modscape",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Modscape: A YAML-driven data modeling visualizer CLI",
   "repository": {
     "type": "git",

package/src/column.js

@@ -0,0 +1,100 @@
+import { Command } from 'commander';
+import { readYaml, writeYaml, findTableById, outputError, outputWarn, outputOk } from './model-utils.js';
+
+function findColumnById(table, id) {
+  return (table.columns || []).find(c => c.id === id) || null;
+}
+
+export function columnCommand() {
+  const cmd = new Command('column').description('Manage columns in a table');
+
+  // add
+  cmd
+    .command('add <file>')
+    .description('Add a column to a table')
+    .requiredOption('--table <tableId>', 'target table ID')
+    .requiredOption('--id <id>', 'column ID (snake_case)')
+    .requiredOption('--name <name>', 'logical name')
+    .option('--type <type>', 'logical type (Int|String|Decimal|Date|Timestamp|Boolean|...)')
+    .option('--primary-key', 'mark as primary key')
+    .option('--foreign-key', 'mark as foreign key')
+    .option('--physical-name <name>', 'physical column name')
+    .option('--physical-type <type>', 'physical column type (e.g. BIGINT)')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const table = findTableById(data, opts.table);
+      if (!table) return outputError(opts.json, `Table "${opts.table}" not found`);
+      if (findColumnById(table, opts.id)) {
+        return outputError(opts.json, `Column "${opts.id}" already exists in table "${opts.table}"`, 'Use `column update` instead');
+      }
+      const column = { id: opts.id, logical: { name: opts.name } };
+      if (opts.type) column.logical.type = opts.type;
+      if (opts.primaryKey) column.logical.isPrimaryKey = true;
+      if (opts.foreignKey) column.logical.isForeignKey = true;
+      if (opts.physicalName || opts.physicalType) {
+        column.physical = {};
+        if (opts.physicalName) column.physical.name = opts.physicalName;
+        if (opts.physicalType) column.physical.type = opts.physicalType;
+      }
+      if (!table.columns) table.columns = [];
+      table.columns.push(column);
+      writeYaml(file, data);
+      outputOk(opts.json, 'add', 'column', `${opts.table}.${opts.id}`);
+    });
+
+  // update
+  cmd
+    .command('update <file>')
+    .description('Update a column in a table')
+    .requiredOption('--table <tableId>', 'target table ID')
+    .requiredOption('--id <id>', 'column ID to update')
+    .option('--name <name>', 'logical name')
+    .option('--type <type>', 'logical type')
+    .option('--primary-key <bool>', 'set isPrimaryKey (true|false)')
+    .option('--foreign-key <bool>', 'set isForeignKey (true|false)')
+    .option('--physical-name <name>', 'physical column name')
+    .option('--physical-type <type>', 'physical column type')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const table = findTableById(data, opts.table);
+      if (!table) return outputError(opts.json, `Table "${opts.table}" not found`);
+      const column = findColumnById(table, opts.id);
+      if (!column) return outputError(opts.json, `Column "${opts.id}" not found in table "${opts.table}"`, 'Use `column add` instead');
+      column.logical = column.logical || {};
+      if (opts.name) column.logical.name = opts.name;
+      if (opts.type) column.logical.type = opts.type;
+      if (opts.primaryKey !== undefined) column.logical.isPrimaryKey = opts.primaryKey === 'true';
+      if (opts.foreignKey !== undefined) column.logical.isForeignKey = opts.foreignKey === 'true';
+      if (opts.physicalName || opts.physicalType) {
+        column.physical = column.physical || {};
+        if (opts.physicalName) column.physical.name = opts.physicalName;
+        if (opts.physicalType) column.physical.type = opts.physicalType;
+      }
+      writeYaml(file, data);
+      outputOk(opts.json, 'update', 'column', `${opts.table}.${opts.id}`);
+    });
+
+  // remove
+  cmd
+    .command('remove <file>')
+    .description('Remove a column from a table')
+    .requiredOption('--table <tableId>', 'target table ID')
+    .requiredOption('--id <id>', 'column ID to remove')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const table = findTableById(data, opts.table);
+      if (!table) return outputError(opts.json, `Table "${opts.table}" not found`);
+      const before = (table.columns || []).length;
+      table.columns = (table.columns || []).filter(c => c.id !== opts.id);
+      if (table.columns.length === before) {
+        return outputWarn(opts.json, `Column "${opts.id}" not found in table "${opts.table}", nothing removed`);
+      }
+      writeYaml(file, data);
+      outputOk(opts.json, 'remove', 'column', `${opts.table}.${opts.id}`);
+    });
+
+  return cmd;
+}

package/src/domain.js

@@ -0,0 +1,149 @@
+import { Command } from 'commander';
+import { readYaml, writeYaml, findTableById, findDomainById, outputError, outputWarn, outputOk } from './model-utils.js';
+
+export function domainCommand() {
+  const cmd = new Command('domain').description('Manage domains in a YAML model');
+
+  // list
+  cmd
+    .command('list <file>')
+    .description('List all domains')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const domains = (data.domains || []).map(d => ({ id: d.id, name: d.name }));
+      if (opts.json) {
+        console.log(JSON.stringify(domains));
+      } else {
+        if (domains.length === 0) {
+          console.log('  (no domains)');
+        } else {
+          domains.forEach(d => console.log(`  ${d.id}  ${d.name || ''}`));
+        }
+      }
+    });
+
+  // get
+  cmd
+    .command('get <file>')
+    .description('Get a domain definition by ID')
+    .requiredOption('--id <id>', 'domain ID')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const domain = findDomainById(data, opts.id);
+      if (!domain) return outputError(opts.json, `Domain "${opts.id}" not found`);
+      if (opts.json) {
+        console.log(JSON.stringify(domain));
+      } else {
+        console.log(JSON.stringify(domain, null, 2));
+      }
+    });
+
+  // add
+  cmd
+    .command('add <file>')
+    .description('Add a new domain')
+    .requiredOption('--id <id>', 'domain ID (snake_case)')
+    .requiredOption('--name <name>', 'display name')
+    .option('--description <text>', 'description')
+    .option('--color <color>', 'background color (e.g. rgba(59,130,246,0.1))')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      if (findDomainById(data, opts.id)) {
+        return outputError(opts.json, `Domain "${opts.id}" already exists`, 'Use `domain update` instead');
+      }
+      const domain = { id: opts.id, name: opts.name, tables: [] };
+      if (opts.description) domain.description = opts.description;
+      if (opts.color) domain.color = opts.color;
+      if (!data.domains) data.domains = [];
+      data.domains.push(domain);
+      writeYaml(file, data);
+      outputOk(opts.json, 'add', 'domain', opts.id);
+    });
+
+  // update
+  cmd
+    .command('update <file>')
+    .description('Update fields of an existing domain')
+    .requiredOption('--id <id>', 'domain ID to update')
+    .option('--name <name>', 'display name')
+    .option('--description <text>', 'description')
+    .option('--color <color>', 'background color')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const domain = findDomainById(data, opts.id);
+      if (!domain) return outputError(opts.json, `Domain "${opts.id}" not found`, 'Use `domain add` instead');
+      if (opts.name) domain.name = opts.name;
+      if (opts.description) domain.description = opts.description;
+      if (opts.color) domain.color = opts.color;
+      writeYaml(file, data);
+      outputOk(opts.json, 'update', 'domain', opts.id);
+    });
+
+  // remove
+  cmd
+    .command('remove <file>')
+    .description('Remove a domain from the model')
+    .requiredOption('--id <id>', 'domain ID to remove')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const before = (data.domains || []).length;
+      data.domains = (data.domains || []).filter(d => d.id !== opts.id);
+      if (data.domains.length === before) {
+        return outputWarn(opts.json, `Domain "${opts.id}" not found, nothing removed`);
+      }
+      writeYaml(file, data);
+      outputOk(opts.json, 'remove', 'domain', opts.id);
+    });
+
+  // member subcommand
+  const member = new Command('member').description('Manage table membership in a domain');
+
+  member
+    .command('add <file>')
+    .description('Add a table to a domain')
+    .requiredOption('--domain <domainId>', 'domain ID')
+    .requiredOption('--table <tableId>', 'table ID to add')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const domain = findDomainById(data, opts.domain);
+      if (!domain) return outputError(opts.json, `Domain "${opts.domain}" not found`);
+      if (!findTableById(data, opts.table)) {
+        return outputError(opts.json, `Table "${opts.table}" not found`);
+      }
+      if (!domain.tables) domain.tables = [];
+      if (domain.tables.includes(opts.table)) {
+        return outputWarn(opts.json, `Table "${opts.table}" is already in domain "${opts.domain}", skipped`);
+      }
+      domain.tables.push(opts.table);
+      writeYaml(file, data);
+      outputOk(opts.json, 'member_add', 'domain', `${opts.domain} ← ${opts.table}`);
+    });
+
+  member
+    .command('remove <file>')
+    .description('Remove a table from a domain')
+    .requiredOption('--domain <domainId>', 'domain ID')
+    .requiredOption('--table <tableId>', 'table ID to remove')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const domain = findDomainById(data, opts.domain);
+      if (!domain) return outputError(opts.json, `Domain "${opts.domain}" not found`);
+      const before = (domain.tables || []).length;
+      domain.tables = (domain.tables || []).filter(t => t !== opts.table);
+      if (domain.tables.length === before) {
+        return outputWarn(opts.json, `Table "${opts.table}" not found in domain "${opts.domain}", nothing removed`);
+      }
+      writeYaml(file, data);
+      outputOk(opts.json, 'member_remove', 'domain', `${opts.domain} ✕ ${opts.table}`);
+    });
+
+  cmd.addCommand(member);
+  return cmd;
+}

package/src/extract.js

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+const collectYamlFiles = (inputPath) => {
+  const stat = fs.statSync(inputPath);
+  if (stat.isDirectory()) {
+    return fs.readdirSync(inputPath)
+      .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
+      .map(f => path.join(inputPath, f));
+  }
+  return [inputPath];
+};
+
+export function extractModels(inputs, options) {
+  const outputPath = options.output || 'extracted.yaml';
+  const tableIds = options.tables
+    ? options.tables.split(',').map(id => id.trim()).filter(Boolean)
+    : [];
+
+  if (tableIds.length === 0) {
+    console.error('  ❌ --tables option is required. Specify comma-separated table IDs.');
+    return;
+  }
+
+  // 後勝ちマージ用 Map
+  const tableMap = new Map();
+
+  const allFiles = [];
+  for (const input of inputs) {
+    allFiles.push(...collectYamlFiles(input));
+  }
+
+  if (allFiles.length === 0) {
+    console.error('  ❌ No YAML files found');
+    return;
+  }
+
+  for (const filePath of allFiles) {
+    try {
+      const data = yaml.load(fs.readFileSync(filePath, 'utf8'));
+      if (!data) continue;
+
+      let matched = 0;
+      for (const table of data.tables || []) {
+        if (tableIds.includes(table.id)) {
+          tableMap.set(table.id, table); // 後勝ち上書き
+          matched++;
+        }
+      }
+
+      console.log(`  📄 ${filePath} (${matched} matched)`);
+    } catch (e) {
+      console.error(`  ❌ Failed to read ${filePath}: ${e.message}`);
+    }
+  }
+
+  // マッチしなかった ID を警告
+  for (const id of tableIds) {
+    if (!tableMap.has(id)) {
+      console.warn(`  ⚠️  Table ID not found: "${id}"`);
+    }
+  }
+
+  const outputModel = {
+    tables: [...tableMap.values()],
+  };
+
+  fs.writeFileSync(outputPath, yaml.dump(outputModel), 'utf8');
+  console.log(`\n  ✅ Extracted ${tableMap.size} tables → ${outputPath}`);
+  console.log(`  🚀 Run 'modscape dev ${outputPath}' to visualize.`);
+}

package/src/index.js

@@ -12,8 +12,14 @@ import { importDbt } from './import-dbt.js';
 import { syncDbt } from './sync-dbt.js';
 import { applyLayout } from './layout.js';
 import { createRequire } from 'module';
-  import { mergeModels } from './merge.js';
-  
+import { mergeModels } from './merge.js';
+import { extractModels } from './extract.js';
+import { tableCommand } from './table.js';
+import { columnCommand } from './column.js';
+import { relationshipCommand } from './relationship.js';
+import { lineageCommand } from './lineage.js';
+import { domainCommand } from './domain.js';
+
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 
@@ -105,6 +111,22 @@ program
     mergeModels(paths, options);
   });
 
+program
+  .command('extract')
+  .description('Extract specific tables from YAML models by ID')
+  .argument('<paths...>', 'YAML files or directories to extract from')
+  .option('-t, --tables <ids>', 'comma-separated table IDs to extract')
+  .option('-o, --output <path>', 'output file path', 'extracted.yaml')
+  .action((paths, options) => {
+    extractModels(paths, options);
+  });
+
+program.addCommand(tableCommand());
+program.addCommand(columnCommand());
+program.addCommand(relationshipCommand());
+program.addCommand(lineageCommand());
+program.addCommand(domainCommand());
+
 program
   .command('layout')
   .description('Perform automatic layout calculation and update the YAML file')

package/src/lineage.js

@@ -0,0 +1,69 @@
+import { Command } from 'commander';
+import { readYaml, writeYaml, findTableById, outputError, outputWarn, outputOk } from './model-utils.js';
+
+export function lineageCommand() {
+  const cmd = new Command('lineage').description('Manage data lineage in a YAML model');
+
+  // list
+  cmd
+    .command('list <file>')
+    .description('List all lineage entries')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const entries = data.lineage || [];
+      if (opts.json) {
+        console.log(JSON.stringify(entries));
+      } else {
+        if (entries.length === 0) {
+          console.log('  (no lineage)');
+        } else {
+          entries.forEach(e => console.log(`  ${e.from} --> ${e.to}`));
+        }
+      }
+    });
+
+  // add
+  cmd
+    .command('add <file>')
+    .description('Add a lineage entry (data flow from → to)')
+    .requiredOption('--from <tableId>', 'upstream table ID')
+    .requiredOption('--to <tableId>', 'downstream table ID')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      if (!findTableById(data, opts.from)) {
+        return outputError(opts.json, `Table "${opts.from}" not found`);
+      }
+      if (!findTableById(data, opts.to)) {
+        return outputError(opts.json, `Table "${opts.to}" not found`);
+      }
+      const entries = data.lineage || [];
+      if (entries.some(e => e.from === opts.from && e.to === opts.to)) {
+        return outputWarn(opts.json, `Lineage ${opts.from} → ${opts.to} already exists, skipped`);
+      }
+      data.lineage = [...entries, { from: opts.from, to: opts.to }];
+      writeYaml(file, data);
+      outputOk(opts.json, 'add', 'lineage', `${opts.from} → ${opts.to}`);
+    });
+
+  // remove
+  cmd
+    .command('remove <file>')
+    .description('Remove a lineage entry')
+    .requiredOption('--from <tableId>', 'upstream table ID')
+    .requiredOption('--to <tableId>', 'downstream table ID')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const before = (data.lineage || []).length;
+      data.lineage = (data.lineage || []).filter(e => !(e.from === opts.from && e.to === opts.to));
+      if (data.lineage.length === before) {
+        return outputWarn(opts.json, `Lineage ${opts.from} → ${opts.to} not found, nothing removed`);
+      }
+      writeYaml(file, data);
+      outputOk(opts.json, 'remove', 'lineage', `${opts.from} → ${opts.to}`);
+    });
+
+  return cmd;
+}

package/src/model-utils.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import yaml from 'js-yaml';
+
+export function readYaml(filePath) {
+  const data = yaml.load(fs.readFileSync(filePath, 'utf8'));
+  return data || {};
+}
+
+export function writeYaml(filePath, data) {
+  fs.writeFileSync(filePath, yaml.dump(data, { lineWidth: -1 }), 'utf8');
+}
+
+export function findTableById(data, id) {
+  return (data.tables || []).find(t => t.id === id) || null;
+}
+
+export function findDomainById(data, id) {
+  return (data.domains || []).find(d => d.id === id) || null;
+}
+
+export function output(json, message, opts = {}) {
+  if (opts.json) {
+    console.log(JSON.stringify(message));
+  } else {
+    console.log(message);
+  }
+}
+
+export function outputError(json, message, hint) {
+  if (json) {
+    console.error(JSON.stringify({ ok: false, error: message, hint: hint || '' }));
+  } else {
+    console.error(`  ❌ ${message}${hint ? '\n  💡 ' + hint : ''}`);
+  }
+  process.exit(1);
+}
+
+export function outputWarn(json, message) {
+  if (json) {
+    console.error(JSON.stringify({ ok: false, warning: message }));
+  } else {
+    console.warn(`  ⚠️  ${message}`);
+  }
+}
+
+export function outputOk(json, action, resource, id, extra = {}) {
+  if (json) {
+    console.log(JSON.stringify({ ok: true, action, resource, id, ...extra }));
+  } else {
+    const icons = { add: '✅', update: '✏️', remove: '🗑️', list: '📋', get: '🔍', member_add: '✅', member_remove: '🗑️' };
+    console.log(`  ${icons[action] || '✅'} ${action} ${resource}: ${id}`);
+  }
+}

package/src/relationship.js

@@ -0,0 +1,93 @@
+import { Command } from 'commander';
+import { readYaml, writeYaml, findTableById, outputError, outputWarn, outputOk } from './model-utils.js';
+
+// Parse "table.column" or "table" into { tableId, columnId }
+function parseRef(ref) {
+  const parts = ref.split('.');
+  return { tableId: parts[0], columnId: parts[1] || null };
+}
+
+function sameRel(r, fromTableId, toTableId) {
+  return r.from?.table === fromTableId && r.to?.table === toTableId;
+}
+
+export function relationshipCommand() {
+  const cmd = new Command('relationship').description('Manage relationships in a YAML model');
+
+  // list
+  cmd
+    .command('list <file>')
+    .description('List all relationships')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const rels = data.relationships || [];
+      if (opts.json) {
+        console.log(JSON.stringify(rels));
+      } else {
+        if (rels.length === 0) {
+          console.log('  (no relationships)');
+        } else {
+          rels.forEach(r => {
+            const from = r.from?.column ? `${r.from.table}.${r.from.column}` : r.from?.table;
+            const to = r.to?.column ? `${r.to.table}.${r.to.column}` : r.to?.table;
+            console.log(`  ${from} --[${r.type}]--> ${to}`);
+          });
+        }
+      }
+    });
+
+  // add
+  cmd
+    .command('add <file>')
+    .description('Add a relationship between two tables')
+    .requiredOption('--from <ref>', 'source table (table.column or table)')
+    .requiredOption('--to <ref>', 'target table (table.column or table)')
+    .requiredOption('--type <type>', 'cardinality (one-to-one|one-to-many|many-to-one|many-to-many)')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const from = parseRef(opts.from);
+      const to = parseRef(opts.to);
+      if (!findTableById(data, from.tableId)) {
+        return outputError(opts.json, `Table "${from.tableId}" not found`);
+      }
+      if (!findTableById(data, to.tableId)) {
+        return outputError(opts.json, `Table "${to.tableId}" not found`);
+      }
+      const rels = data.relationships || [];
+      if (rels.some(r => sameRel(r, from.tableId, to.tableId))) {
+        return outputWarn(opts.json, `Relationship ${from.tableId} → ${to.tableId} already exists, skipped`);
+      }
+      const rel = {
+        from: { table: from.tableId, ...(from.columnId ? { column: from.columnId } : {}) },
+        to: { table: to.tableId, ...(to.columnId ? { column: to.columnId } : {}) },
+        type: opts.type,
+      };
+      data.relationships = [...rels, rel];
+      writeYaml(file, data);
+      outputOk(opts.json, 'add', 'relationship', `${opts.from} → ${opts.to}`);
+    });
+
+  // remove
+  cmd
+    .command('remove <file>')
+    .description('Remove a relationship')
+    .requiredOption('--from <ref>', 'source table (table.column or table)')
+    .requiredOption('--to <ref>', 'target table (table.column or table)')
+    .option('--json', 'output as JSON')
+    .action((file, opts) => {
+      const data = readYaml(file);
+      const from = parseRef(opts.from);
+      const to = parseRef(opts.to);
+      const before = (data.relationships || []).length;
+      data.relationships = (data.relationships || []).filter(r => !sameRel(r, from.tableId, to.tableId));
+      if (data.relationships.length === before) {
+        return outputWarn(opts.json, `Relationship ${from.tableId} → ${to.tableId} not found, nothing removed`);
+      }
+      writeYaml(file, data);
+      outputOk(opts.json, 'remove', 'relationship', `${opts.from} → ${opts.to}`);
+    });
+
+  return cmd;
+}