kysely-schema 0.1.0

package/tests/migration.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect } from 'vitest';
+import { MigrationGenerator } from '../src/generators/migration.js';
+import { defineSchema, table, column } from '../src/schema/dsl.js';
+
+describe('MigrationGenerator', () => {
+    const generator = new MigrationGenerator();
+
+    it('generates a valid migration filename', () => {
+        const schema = defineSchema({
+            user: table({ id: column.serial().primaryKey() }),
+        });
+        const migration = generator.generate(schema, 'create_users');
+        expect(migration.filename).toMatch(/^\d{8}T\d{6}_create_users\.ts$/);
+    });
+
+    it('generates CREATE TABLE with addColumn', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                email: column.text().notNull().unique(),
+            }),
+        });
+
+        const migration = generator.generate(schema, 'initial');
+        expect(migration.content).toContain("createTable('user')");
+        expect(migration.content).toContain("addColumn('id', 'serial'");
+        expect(migration.content).toContain("addColumn('email', 'text'");
+        expect(migration.content).toContain('primaryKey()');
+        expect(migration.content).toContain('notNull()');
+        expect(migration.content).toContain('unique()');
+    });
+
+    it('generates default values', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                active: column.boolean().default(false).notNull(),
+                createdAt: column.timestamp().default('now()').notNull(),
+            }),
+        });
+
+        const migration = generator.generate(schema, 'defaults');
+        expect(migration.content).toContain('defaultTo(false)');
+        expect(migration.content).toContain('defaultTo(sql`now()`)');
+    });
+
+    it('generates foreign key constraints', () => {
+        const schema = defineSchema({
+            user: table({ id: column.serial().primaryKey() }),
+            post: table({
+                id: column.serial().primaryKey(),
+                authorId: column
+                    .integer()
+                    .notNull()
+                    .references('user', 'id')
+                    .onDelete('cascade'),
+            }),
+        });
+
+        const migration = generator.generate(schema, 'with_fk');
+        expect(migration.content).toContain("references('user.id')");
+        expect(migration.content).toContain("onDelete('cascade')");
+    });
+
+    it('generates indexes for foreign keys', () => {
+        const schema = defineSchema({
+            user: table({ id: column.serial().primaryKey() }),
+            post: table({
+                id: column.serial().primaryKey(),
+                authorId: column.integer().references('user', 'id'),
+            }),
+        });
+
+        const migration = generator.generate(schema, 'fk_indexes');
+        expect(migration.content).toContain("createIndex('post_authorId_index')");
+        expect(migration.content).toContain(".on('post')");
+        expect(migration.content).toContain(".column('authorId')");
+    });
+
+    it('generates DROP TABLE in reverse order for down()', () => {
+        const schema = defineSchema({
+            user: table({ id: column.serial().primaryKey() }),
+            post: table({ id: column.serial().primaryKey() }),
+            comment: table({ id: column.serial().primaryKey() }),
+        });
+
+        const migration = generator.generate(schema, 'reverse_drop');
+        const downSection = migration.content.split('export async function down')[1];
+        const userIdx = downSection.indexOf("dropTable('user')");
+        const postIdx = downSection.indexOf("dropTable('post')");
+        const commentIdx = downSection.indexOf("dropTable('comment')");
+
+        // comment should be dropped first, then post, then user
+        expect(commentIdx).toBeLessThan(postIdx);
+        expect(postIdx).toBeLessThan(userIdx);
+    });
+
+    it('generates varchar with length', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                name: column.varchar(100).notNull(),
+            }),
+        });
+
+        const migration = generator.generate(schema, 'varchar');
+        expect(migration.content).toContain("addColumn('name', 'varchar(100)'");
+    });
+
+    it('generates decimal with precision and scale', () => {
+        const schema = defineSchema({
+            product: table({
+                id: column.serial().primaryKey(),
+                price: column.decimal(10, 2).notNull(),
+            }),
+        });
+
+        const migration = generator.generate(schema, 'decimal');
+        expect(migration.content).toContain("addColumn('price', 'decimal(10, 2)'");
+    });
+
+    it('imports Kysely and sql', () => {
+        const schema = defineSchema({
+            user: table({ id: column.serial().primaryKey() }),
+        });
+
+        const migration = generator.generate(schema, 'imports');
+        expect(migration.content).toContain("import { Kysely, sql } from 'kysely'");
+    });
+
+    it('generates up and down functions', () => {
+        const schema = defineSchema({
+            user: table({ id: column.serial().primaryKey() }),
+        });
+
+        const migration = generator.generate(schema, 'up_down');
+        expect(migration.content).toContain('export async function up');
+        expect(migration.content).toContain('export async function down');
+    });
+});

package/tests/types.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import { TypeGenerator } from '../src/generators/types.js';
+import { defineSchema, table, column } from '../src/schema/dsl.js';
+
+describe('TypeGenerator', () => {
+    const generator = new TypeGenerator();
+
+    it('generates a Database interface', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                email: column.text().notNull(),
+            }),
+        });
+
+        const output = generator.generate(schema);
+        expect(output).toContain('export interface Database');
+        expect(output).toContain('user: UserTable');
+    });
+
+    it('generates per-table interfaces', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                name: column.text().notNull(),
+            }),
+        });
+
+        const output = generator.generate(schema);
+        expect(output).toContain('export interface UserTable');
+        expect(output).toContain('id: Generated<number>');
+        expect(output).toContain('name: string');
+    });
+
+    it('maps serial to Generated<number>', () => {
+        const schema = defineSchema({
+            t: table({ id: column.serial().primaryKey() }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('id: Generated<number>');
+    });
+
+    it('maps integer to number', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                count: column.integer().notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('count: number');
+    });
+
+    it('maps bigint to string', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                big: column.bigint().notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('big: string');
+    });
+
+    it('maps text and varchar to string', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                a: column.text().notNull(),
+                b: column.varchar(100).notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('a: string');
+        expect(output).toContain('b: string');
+    });
+
+    it('maps timestamp and date to Date', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                ts: column.timestamp().notNull(),
+                d: column.date().notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('ts: Date');
+        expect(output).toContain('d: Date');
+    });
+
+    it('maps boolean to boolean', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                active: column.boolean().notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('active: boolean');
+    });
+
+    it('maps json/jsonb to unknown', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                data: column.json().notNull(),
+                meta: column.jsonb().notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('data: unknown');
+        expect(output).toContain('meta: unknown');
+    });
+
+    it('maps uuid to string', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                uid: column.uuid().notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('uid: string');
+    });
+
+    it('marks nullable columns with | null', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                bio: column.text().nullable(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('bio: string | null');
+    });
+
+    it('wraps columns with default in Generated<>', () => {
+        const schema = defineSchema({
+            t: table({
+                id: column.serial().primaryKey(),
+                active: column.boolean().default(true).notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('active: Generated<boolean>');
+    });
+
+    it('includes auto-generated header comment', () => {
+        const schema = defineSchema({
+            t: table({ id: column.serial().primaryKey() }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('Auto-generated by kysely-schema');
+        expect(output).toContain('DO NOT EDIT');
+    });
+
+    it('imports Generated and ColumnType from kysely', () => {
+        const schema = defineSchema({
+            t: table({ id: column.serial().primaryKey() }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain("from 'kysely'");
+    });
+
+    it('handles PascalCase conversion for multi-word table names', () => {
+        const schema = defineSchema({
+            user_profile: table({
+                id: column.serial().primaryKey(),
+                displayName: column.text().notNull(),
+            }),
+        });
+        const output = generator.generate(schema);
+        expect(output).toContain('export interface UserProfileTable');
+        expect(output).toContain('user_profile: UserProfileTable');
+    });
+});

package/tests/validators.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest';
+import { validateSchema } from '../src/schema/validators.js';
+import { defineSchema, table, column } from '../src/schema/dsl.js';
+
+describe('validateSchema()', () => {
+    it('returns no errors for a valid schema', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                email: column.text().notNull().unique(),
+            }),
+        });
+        expect(validateSchema(schema)).toEqual([]);
+    });
+
+    it('reports missing primary key', () => {
+        const schema = defineSchema({
+            user: table({
+                name: column.text().notNull(),
+            }),
+        });
+        const errors = validateSchema(schema);
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toContain('primary key');
+    });
+
+    it('reports notNull + nullable conflict', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                name: column.text().notNull().nullable(),
+            }),
+        });
+        const errors = validateSchema(schema);
+        const conflict = errors.find((e) => e.column === 'name');
+        expect(conflict).toBeDefined();
+        expect(conflict!.message).toContain('notNull and nullable');
+    });
+
+    it('reports foreign key to unknown table', () => {
+        const schema = defineSchema({
+            post: table({
+                id: column.serial().primaryKey(),
+                authorId: column.integer().references('user', 'id'),
+            }),
+        });
+        const errors = validateSchema(schema);
+        const fkError = errors.find((e) => e.column === 'authorId');
+        expect(fkError).toBeDefined();
+        expect(fkError!.message).toContain("unknown table 'user'");
+    });
+
+    it('reports foreign key to unknown column', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+            }),
+            post: table({
+                id: column.serial().primaryKey(),
+                authorId: column.integer().references('user', 'uid'),
+            }),
+        });
+        const errors = validateSchema(schema);
+        const fkError = errors.find((e) => e.column === 'authorId');
+        expect(fkError).toBeDefined();
+        expect(fkError!.message).toContain("unknown column 'uid'");
+    });
+
+    it('reports onDelete without references', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                val: column.integer().onDelete('cascade'),
+            }),
+        });
+        const errors = validateSchema(schema);
+        expect(errors.some((e) => e.message.includes('onDelete'))).toBe(true);
+    });
+
+    it('reports invalid varchar length', () => {
+        const schema = defineSchema({
+            user: table({
+                id: column.serial().primaryKey(),
+                name: column.varchar(0),
+            }),
+        });
+        const errors = validateSchema(schema);
+        expect(errors.some((e) => e.message.includes('varchar length'))).toBe(true);
+    });
+
+    it('reports decimal scale > precision', () => {
+        const schema = defineSchema({
+            product: table({
+                id: column.serial().primaryKey(),
+                price: column.decimal(2, 10),
+            }),
+        });
+        const errors = validateSchema(schema);
+        expect(errors.some((e) => e.message.includes('scale cannot exceed'))).toBe(true);
+    });
+
+    it('valid schema with foreign keys passes', () => {
+        const schema = defineSchema({
+            user: table({ id: column.serial().primaryKey() }),
+            post: table({
+                id: column.serial().primaryKey(),
+                authorId: column
+                    .integer()
+                    .notNull()
+                    .references('user', 'id')
+                    .onDelete('cascade'),
+            }),
+        });
+        expect(validateSchema(schema)).toEqual([]);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src"
+    },
+    "include": [
+        "src/**/*.ts"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "tests"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['esm', 'cjs'],
+    dts: true,
+    clean: true,
+    target: 'es2022',
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        include: ['tests/**/*.test.ts'],
+    },
+});