supatool 0.3.6 → 0.3.7

package/dist/generator/sqlGenerator.js

@@ -65,26 +65,54 @@ function generateSqlFromModel(model, outPath) {
                 }
             }
             let def = `  ${actualColName} ${toSqlType(c.type, actualColName)}`;
-            if (c.primary)
-                def += ' PRIMARY KEY';
-            if (c.unique)
-                def += ' UNIQUE';
             if (c.notNull)
                 def += ' NOT NULL';
             if (c.default)
                 def += ` DEFAULT ${c.default}`;
-            // 外部キー制約はテーブル末尾に付与するため保留
             colDefs.push(def);
-            // 外部キー制約をテーブル末尾に格納
-            if (c.ref) {
-                const refTable = c.ref.split('.')[0];
-                tableConstraints.push(`  FOREIGN KEY (${actualColName}) REFERENCES ${refTable}(id)`);
+        }
+        // 主キー制約（constraint名付き）
+        const pkCols = Object.entries(t.fields || {})
+            .filter(([_, col]) => col.primary)
+            .map(([colName, _]) => colName);
+        if (pkCols.length > 0) {
+            tableConstraints.push(`  CONSTRAINT ${tableName}_pkey PRIMARY KEY (${pkCols.join(', ')})`);
+        }
+        // ユニーク制約（constraint名付き）
+        if (Array.isArray(t.uniques)) {
+            for (const unique of t.uniques) {
+                if (Array.isArray(unique.columns) && unique.name) {
+                    tableConstraints.push(`  CONSTRAINT ${unique.name} UNIQUE (${unique.columns.join(', ')})`);
+                }
+            }
+        }
+        // 外部キー制約（constraint名付き）
+        if (Array.isArray(t.foreignKeys)) {
+            for (const fk of t.foreignKeys) {
+                if (fk.name && fk.columns && fk.refTable && fk.refColumns) {
+                    let fkStr = `  CONSTRAINT ${fk.name} FOREIGN KEY (${fk.columns.join(', ')}) REFERENCES ${fk.refTable} (${fk.refColumns.join(', ')})`;
+                    if (fk.onDelete)
+                        fkStr += ` ON DELETE ${fk.onDelete}`;
+                    if (fk.onUpdate)
+                        fkStr += ` ON UPDATE ${fk.onUpdate}`;
+                    tableConstraints.push(fkStr);
+                }
+            }
+        }
+        // チェック制約（constraint名付き）
+        if (Array.isArray(t.checkConstraints)) {
+            for (const check of t.checkConstraints) {
+                if (check.name) {
+                    tableConstraints.push(`  CONSTRAINT ${check.name} CHECK (${check.expression})`);
+                }
+                else {
+                    tableConstraints.push(`  CHECK (${check.expression})`);
+                }
             }
         }
         // 列定義 + テーブルレベル制約を結合
         const defs = [...colDefs, ...tableConstraints];
         sql += defs.join(',\n') + '\n);\n\n';
-        // ALTER TABLEによる外部キー制約は出力しない
         sql += '\n';
     }
     fs_1.default.writeFileSync(outPath, sql);

package/dist/sync/definitionExtractor.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractDefinitions = extractDefinitions;
+exports.generateCreateTableDDL = generateCreateTableDDL;
 const pg_1 = require("pg");
 /**
  * 進行状況を表示
@@ -869,6 +870,22 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
     for (const fk of foreignKeyResult.rows) {
         ddl += `,\n  CONSTRAINT ${fk.constraint_name} FOREIGN KEY (${fk.columns}) REFERENCES ${fk.foreign_table_schema}.${fk.foreign_table_name} (${fk.foreign_columns})`;
     }
+    // CHECK制約をCREATE TABLE内に追加（必ず最後）
+    const checkConstraintResult = await client.query(`
+    SELECT 
+      con.conname as constraint_name,
+      pg_get_constraintdef(con.oid) as check_clause
+    FROM pg_constraint con
+    JOIN pg_class rel ON rel.oid = con.conrelid
+    JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+    WHERE lower(rel.relname) = lower($1)
+      AND nsp.nspname = $2
+      AND con.contype = 'c'
+    ORDER BY con.conname
+  `, [tableName, schemaName]);
+    for (const check of checkConstraintResult.rows) {
+        ddl += `,\n  CONSTRAINT ${check.constraint_name} ${check.check_clause}`;
+    }
     ddl += '\n);\n\n';
     // COMMENT ON文を追加
     if (tableCommentResult.rows.length > 0 && tableCommentResult.rows[0].table_comment) {

package/dist/sync/fetchRemoteSchemas.js

@@ -37,6 +37,7 @@ exports.fetchRemoteSchemas = fetchRemoteSchemas;
 const pg_1 = require("pg");
 const dns = __importStar(require("dns"));
 const util_1 = require("util");
+const definitionExtractor_1 = require("./definitionExtractor");
 const dnsLookup = (0, util_1.promisify)(dns.lookup);
 /**
  * DDL文字列を正規化（空白・改行・タブを統一）
@@ -163,162 +164,32 @@ async function fetchRemoteSchemas(connectionString) {
         // 各テーブルのスキーマ情報を取得
         for (const row of tablesResult.rows) {
             const tableName = row.tablename;
-            // テーブルの最終更新時刻を取得（複数の方法を試行）
-            let timestamp = Math.floor(Date.now() / 1000); // デフォルト値
-            // pg_stat_user_tablesから取得
+            // テーブルの最終更新時刻を取得（省略: 既存ロジック流用）
+            let timestamp = Math.floor(Date.now() / 1000);
             try {
                 const tableStatsResult = await client.query(`
-           SELECT 
-             EXTRACT(EPOCH FROM GREATEST(
-               COALESCE(last_vacuum, '1970-01-01'::timestamp),
-               COALESCE(last_autovacuum, '1970-01-01'::timestamp),
-               COALESCE(last_analyze, '1970-01-01'::timestamp),
-               COALESCE(last_autoanalyze, '1970-01-01'::timestamp)
-             ))::bigint as last_updated
-           FROM pg_stat_user_tables 
-           WHERE relname = $1 AND schemaname = 'public'
-         `, [tableName]);
+          SELECT 
+            EXTRACT(EPOCH FROM GREATEST(
+              COALESCE(last_vacuum, '1970-01-01'::timestamp),
+              COALESCE(last_autovacuum, '1970-01-01'::timestamp),
+              COALESCE(last_analyze, '1970-01-01'::timestamp),
+              COALESCE(last_autoanalyze, '1970-01-01'::timestamp)
+            ))::bigint as last_updated
+          FROM pg_stat_user_tables 
+          WHERE relname = $1 AND schemaname = 'public'
+        `, [tableName]);
                 if (tableStatsResult.rows.length > 0 && tableStatsResult.rows[0].last_updated > 0) {
                     timestamp = tableStatsResult.rows[0].last_updated;
                 }
                 else {
-                    // デフォルトタイムスタンプ（十分に古い固定値）
                     timestamp = Math.floor(new Date('2020-01-01').getTime() / 1000);
                 }
             }
-            catch (statsError) {
-                // デフォルトタイムスタンプ（十分に古い固定値）
+            catch {
                 timestamp = Math.floor(new Date('2020-01-01').getTime() / 1000);
             }
-            // カラム情報を取得
-            const columnsResult = await client.query(`
-        SELECT 
-          column_name,
-          data_type,
-          character_maximum_length,
-          is_nullable,
-          column_default
-        FROM information_schema.columns 
-        WHERE table_schema = 'public' 
-          AND table_name = $1
-        ORDER BY ordinal_position
-      `, [tableName]);
-            // 主キー情報を取得
-            const primaryKeyResult = await client.query(`
-        SELECT column_name
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-        WHERE tc.table_schema = 'public'
-          AND tc.table_name = $1
-          AND tc.constraint_type = 'PRIMARY KEY'
-        ORDER BY kcu.ordinal_position
-      `, [tableName]);
-            // CREATE TABLE文を生成
-            let ddl = `CREATE TABLE IF NOT EXISTS ${tableName} (\n`;
-            const columnDefs = [];
-            for (const col of columnsResult.rows) {
-                let colDef = `  ${col.column_name} ${col.data_type.toUpperCase()}`;
-                // 長さ指定
-                if (col.character_maximum_length) {
-                    colDef += `(${col.character_maximum_length})`;
-                }
-                // NOT NULL制約
-                if (col.is_nullable === 'NO') {
-                    colDef += ' NOT NULL';
-                }
-                // デフォルト値
-                if (col.column_default) {
-                    colDef += ` DEFAULT ${col.column_default}`;
-                }
-                columnDefs.push(colDef);
-            }
-            ddl += columnDefs.join(',\n');
-            // 主キー制約
-            if (primaryKeyResult.rows.length > 0) {
-                const pkColumns = primaryKeyResult.rows.map(row => row.column_name);
-                ddl += `,\n  PRIMARY KEY (${pkColumns.join(', ')})`;
-            }
-            // UNIQUE制約を取得してCREATE TABLE内に含める
-            const uniqueConstraintResult = await client.query(`
-        SELECT 
-          tc.constraint_name,
-          string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) as columns
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-        WHERE tc.table_schema = 'public'
-          AND tc.table_name = $1
-          AND tc.constraint_type = 'UNIQUE'
-        GROUP BY tc.constraint_name
-        ORDER BY tc.constraint_name
-      `, [tableName]);
-            // UNIQUE制約をCREATE TABLE内に追加
-            for (const unique of uniqueConstraintResult.rows) {
-                ddl += `,\n  CONSTRAINT ${unique.constraint_name} UNIQUE (${unique.columns})`;
-            }
-            // CHECK制約は一時的に無効化（NOT NULL制約と重複するため）
-            // const checkConstraintResult = await client.query(`...`);
-            // CHECK制約をCREATE TABLE内に追加は一時的に無効化
-            // for (const check of checkConstraintResult.rows) {
-            //   ddl += `,\n  CONSTRAINT ${check.constraint_name} CHECK ${check.check_clause}`;
-            // }
-            ddl += '\n);';
-            // 外部キー制約のみを別途生成
-            const foreignKeyResult = await client.query(`
-        SELECT 
-          tc.constraint_name,
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name,
-          rc.delete_rule,
-          rc.update_rule
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-        JOIN information_schema.constraint_column_usage ccu 
-          ON ccu.constraint_name = tc.constraint_name
-        JOIN information_schema.referential_constraints rc 
-          ON tc.constraint_name = rc.constraint_name
-        WHERE tc.table_schema = 'public'
-          AND tc.table_name = $1
-          AND tc.constraint_type = 'FOREIGN KEY'
-        ORDER BY tc.constraint_name
-      `, [tableName]);
-            // 外部キー制約のみをALTER TABLE文として追加
-            for (const fk of foreignKeyResult.rows) {
-                ddl += `\n\nALTER TABLE ${tableName} ADD CONSTRAINT ${fk.constraint_name}`;
-                ddl += ` FOREIGN KEY (${fk.column_name})`;
-                ddl += ` REFERENCES ${fk.foreign_table_name} (${fk.foreign_column_name})`;
-                if (fk.delete_rule && fk.delete_rule !== 'NO ACTION') {
-                    ddl += ` ON DELETE ${fk.delete_rule}`;
-                }
-                if (fk.update_rule && fk.update_rule !== 'NO ACTION') {
-                    ddl += ` ON UPDATE ${fk.update_rule}`;
-                }
-                ddl += ';';
-            }
-            // インデックス情報を取得
-            const indexResult = await client.query(`
-        SELECT 
-          indexname,
-          indexdef
-        FROM pg_indexes 
-        WHERE schemaname = 'public' 
-          AND tablename = $1
-          AND indexname NOT LIKE '%_pkey'
-          AND indexname NOT IN (
-            SELECT tc.constraint_name 
-            FROM information_schema.table_constraints tc
-            WHERE tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
-          )
-        ORDER BY indexname
-      `, [tableName]);
-            // インデックスを追加
-            for (const idx of indexResult.rows) {
-                ddl += `\n\n${idx.indexdef};`;
-            }
-            // DDLを元の形式で保存
+            // DDL生成をdefinitionExtractorの関数で統一
+            const ddl = await (0, definitionExtractor_1.generateCreateTableDDL)(client, tableName, 'public');
             schemas[tableName] = {
                 ddl,
                 timestamp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supatool",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "A CLI tool for Supabase schema extraction and TypeScript CRUD generation with declarative database schema support.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",