Migrate to typescript

packages/dbml-core/__tests__/examples/exporter/exporter.spec.ts

@@ -5,6 +5,18 @@ import { readFileSync } from 'fs';
 import path from 'path';
 import { test, expect, describe } from 'vitest';
 
+const DBML_WITH_RECORDS = `
+Table users {
+  id integer [pk]
+  name varchar
+}
+
+Records users(id, name) {
+  1, 'Alice'
+  2, 'Bob'
+}
+`.trim();
+
 describe('@dbml/core - exporter', () => {
   const runTest = async (fileName: string, testDir: string, format: ExportFormatOption) => {
     const fileExtension = getFileExtension(format);
@@ -29,3 +41,39 @@ describe('@dbml/core - exporter', () => {
     });
   }
 });
+
+const EXPECTED_DBML_WITH_RECORDS =
+`Table "users" {
+  "id" integer [pk]
+  "name" varchar
+}
+
+Records users(id, name) {
+  1, 'Alice'
+  2, 'Bob'
+}`;
+
+const EXPECTED_DBML_WITHOUT_RECORDS =
+`Table "users" {
+  "id" integer [pk]
+  "name" varchar
+}`;
+
+describe('@dbml/core - exporter flags', () => {
+  describe('includeRecords', () => {
+    test('includes records by default', () => {
+      const res = exporter.export(DBML_WITH_RECORDS, 'dbml');
+      expect(res.trim()).toBe(EXPECTED_DBML_WITH_RECORDS);
+    });
+
+    test('includes records when includeRecords is true', () => {
+      const res = exporter.export(DBML_WITH_RECORDS, 'dbml', { includeRecords: true });
+      expect(res.trim()).toBe(EXPECTED_DBML_WITH_RECORDS);
+    });
+
+    test('omits records when includeRecords is false', () => {
+      const res = exporter.export(DBML_WITH_RECORDS, 'dbml', { includeRecords: false });
+      expect(res.trim()).toBe(EXPECTED_DBML_WITHOUT_RECORDS);
+    });
+  });
+});

packages/dbml-core/__tests__/examples/model_exporter/model_exporter.spec.ts

@@ -5,12 +5,42 @@ import MysqlExporter from '../../../src/export/MysqlExporter';
 import PostgresExporter from '../../../src/export/PostgresExporter';
 import SqlServerExporter from '../../../src/export/SqlServerExporter';
 import OracleExporter from '../../../src/export/OracleExporter';
+import ModelExporter from '../../../src/export/ModelExporter';
 import { scanTestNames, getFileExtension, isEqualExcludeTokenEmpty } from '../testHelpers';
 import { ExportFormatOption } from '../../../types/export/ModelExporter';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { test, expect, describe } from 'vitest';
 
+const DBML_WITH_RECORDS = `
+Table users {
+  id integer [pk]
+  name varchar
+}
+
+Records users(id, name) {
+  1, 'Alice'
+  2, 'Bob'
+}
+`.trim();
+
+const EXPECTED_DBML_WITH_RECORDS =
+`Table "users" {
+  "id" integer [pk]
+  "name" varchar
+}
+
+Records users(id, name) {
+  1, 'Alice'
+  2, 'Bob'
+}`;
+
+const EXPECTED_DBML_WITHOUT_RECORDS =
+`Table "users" {
+  "id" integer [pk]
+  "name" varchar
+}`;
+
 type ExporterClass =
   | typeof DbmlExporter
   | typeof JsonExporter
@@ -114,3 +144,69 @@ describe('@dbml/core - model_exporter dbml_exporter.escapeNote', () => {
     expect(DbmlExporter.escapeNote('hell\\\no')).toBe("'''hell\\\\\no'''");
   });
 });
+
+describe('@dbml/core - DbmlExporter flags', () => {
+  describe('includeRecords', () => {
+    test('includes records by default', () => {
+      const database = (new Parser()).parse(DBML_WITH_RECORDS, 'dbmlv2');
+      const res = DbmlExporter.export(database.normalize());
+      expect(res.trim()).toBe(EXPECTED_DBML_WITH_RECORDS);
+    });
+
+    test('includes records when includeRecords is true', () => {
+      const database = (new Parser()).parse(DBML_WITH_RECORDS, 'dbmlv2');
+      const res = DbmlExporter.export(database.normalize(), { includeRecords: true });
+      expect(res.trim()).toBe(EXPECTED_DBML_WITH_RECORDS);
+    });
+
+    test('omits records when includeRecords is false', () => {
+      const database = (new Parser()).parse(DBML_WITH_RECORDS, 'dbmlv2');
+      const res = DbmlExporter.export(database.normalize(), { includeRecords: false });
+      expect(res.trim()).toBe(EXPECTED_DBML_WITHOUT_RECORDS);
+    });
+  });
+});
+
+describe('@dbml/core - ModelExporter backwards compatibility', () => {
+  test('accepts boolean true as isNormalized (old signature)', () => {
+    const database = (new Parser()).parse(DBML_WITH_RECORDS, 'dbmlv2');
+    const normalizedModel = database.normalize();
+    const resBoolean = ModelExporter.export(normalizedModel, 'dbml', true);
+    const resFlags = ModelExporter.export(normalizedModel, 'dbml', { isNormalized: true });
+    expect(resBoolean).toBe(resFlags);
+    expect(resBoolean.trim()).toBe(EXPECTED_DBML_WITH_RECORDS);
+  });
+
+  test('accepts boolean false as isNormalized (old signature)', () => {
+    const database = (new Parser()).parse(DBML_WITH_RECORDS, 'dbmlv2');
+    const resBoolean = ModelExporter.export(database, 'dbml', false);
+    const resFlags = ModelExporter.export(database, 'dbml', { isNormalized: false });
+    expect(resBoolean).toBe(resFlags);
+    expect(resBoolean.trim()).toBe(EXPECTED_DBML_WITH_RECORDS);
+  });
+});
+
+describe('@dbml/core - JsonExporter backwards compatibility', () => {
+  test('accepts boolean true as isNormalized (old signature)', () => {
+    const database = (new Parser()).parse(DBML_WITH_RECORDS, 'dbmlv2');
+    const normalizedModel = database.normalize();
+    const resBoolean = JsonExporter.export(normalizedModel, true);
+    const resFlags = JsonExporter.export(normalizedModel, { isNormalized: true });
+    expect(resBoolean).toBe(resFlags);
+    // Normalized model is the internal model format — verify the table is present
+    const parsed = JSON.parse(resBoolean);
+    expect(Object.values(parsed.tables as Record<string, { name: string }>).map((t) => t.name)).toContain('users');
+  });
+
+  test('accepts boolean false as isNormalized (old signature)', () => {
+    const database = (new Parser()).parse(DBML_WITH_RECORDS, 'dbmlv2');
+    const resBoolean = JsonExporter.export(database, false);
+    const resFlags = JsonExporter.export(database, { isNormalized: false });
+    expect(resBoolean).toBe(resFlags);
+    // Non-normalized export uses database.export() format: { schemas, notes, records }
+    const parsed = JSON.parse(resBoolean);
+    expect(parsed.schemas[0].tables[0].name).toBe('users');
+    expect(parsed.records[0].tableName).toBe('users');
+    expect(parsed.records[0].columns).toEqual(['id', 'name']);
+  });
+});