@sqldoc/templates 0.0.1

package/src/__tests__/type-mapping.test.ts

@@ -0,0 +1,332 @@
+import { describe, expect, it } from 'vitest'
+import { pgToCsharp } from '../types/pg-to-csharp'
+import { pgToGo } from '../types/pg-to-go'
+import { pgToJava } from '../types/pg-to-java'
+import { pgToKotlin } from '../types/pg-to-kotlin'
+import { pgToPython } from '../types/pg-to-python'
+import { pgToRust } from '../types/pg-to-rust'
+import { pgToTs } from '../types/pg-to-ts'
+
+describe('pgToTs', () => {
+  it('maps text to string', () => {
+    expect(pgToTs('text', false)).toBe('string')
+  })
+
+  it('maps bigint to number by default', () => {
+    expect(pgToTs('bigint', false)).toBe('number')
+  })
+
+  it('handles null-union nullable style', () => {
+    expect(pgToTs('bigint', true, { nullableStyle: 'null-union' })).toBe('number | null')
+  })
+
+  it('maps text[] to string[]', () => {
+    expect(pgToTs('text[]', false)).toBe('string[]')
+  })
+
+  it('maps _text array notation to string[]', () => {
+    expect(pgToTs('_text', false)).toBe('string[]')
+  })
+
+  it('maps timestamptz to Date by default', () => {
+    expect(pgToTs('timestamptz', false)).toBe('Date')
+  })
+
+  it('maps timestamptz with dateType string option', () => {
+    expect(pgToTs('timestamptz', false, { dateType: 'string' })).toBe('string')
+  })
+
+  it('strips length specifier from varchar(255)', () => {
+    expect(pgToTs('varchar(255)', false)).toBe('string')
+  })
+
+  it('maps jsonb to unknown', () => {
+    expect(pgToTs('jsonb', false)).toBe('unknown')
+  })
+
+  it('maps uuid to string', () => {
+    expect(pgToTs('uuid', false)).toBe('string')
+  })
+
+  it('maps boolean to boolean', () => {
+    expect(pgToTs('boolean', false)).toBe('boolean')
+  })
+
+  it('maps bytea to Buffer', () => {
+    expect(pgToTs('bytea', false)).toBe('Buffer')
+  })
+
+  it('maps numeric to string for precision', () => {
+    expect(pgToTs('numeric(10,2)', false)).toBe('string')
+  })
+
+  it('applies bigintType option', () => {
+    expect(pgToTs('bigint', false, { bigintType: 'bigint' })).toBe('bigint')
+  })
+
+  it('returns unknown for unrecognized types', () => {
+    expect(pgToTs('custom_enum', false)).toBe('unknown')
+  })
+
+  it('handles double precision', () => {
+    expect(pgToTs('double precision', false)).toBe('number')
+  })
+
+  // Category-based mapping tests
+  it('maps string category to string', () => {
+    expect(pgToTs('citext', false, {}, 'string')).toBe('string')
+  })
+
+  it('maps integer category to number', () => {
+    expect(pgToTs('some_int', false, {}, 'integer')).toBe('number')
+  })
+
+  it('maps boolean category to boolean', () => {
+    expect(pgToTs('custom_bool', false, {}, 'boolean')).toBe('boolean')
+  })
+
+  it('maps time category to Date', () => {
+    expect(pgToTs('custom_ts', false, {}, 'time')).toBe('Date')
+  })
+
+  it('maps json category to unknown', () => {
+    expect(pgToTs('custom_json', false, {}, 'json')).toBe('unknown')
+  })
+
+  it('maps uuid category to string', () => {
+    expect(pgToTs('custom_uuid', false, {}, 'uuid')).toBe('string')
+  })
+
+  it('falls back to raw type when no category', () => {
+    expect(pgToTs('text', false, {}, undefined)).toBe('string')
+  })
+
+  it('category with nullable null-union', () => {
+    expect(pgToTs('custom_int', true, { nullableStyle: 'null-union' }, 'integer')).toBe('number | null')
+  })
+})
+
+describe('pgToGo', () => {
+  it('maps text to string', () => {
+    expect(pgToGo('text', false)).toEqual({ type: 'string', imports: [] })
+  })
+
+  it('maps timestamptz nullable to *time.Time', () => {
+    expect(pgToGo('timestamptz', true)).toEqual({ type: '*time.Time', imports: ['time'] })
+  })
+
+  it('maps jsonb to json.RawMessage', () => {
+    expect(pgToGo('jsonb', false)).toEqual({ type: 'json.RawMessage', imports: ['encoding/json'] })
+  })
+
+  it('maps uuid to uuid.UUID', () => {
+    expect(pgToGo('uuid', false)).toEqual({ type: 'uuid.UUID', imports: ['github.com/google/uuid'] })
+  })
+
+  it('maps text[] to []string', () => {
+    expect(pgToGo('text[]', false)).toEqual({ type: '[]string', imports: [] })
+  })
+
+  it('maps nullable text to pointer', () => {
+    expect(pgToGo('text', true)).toEqual({ type: '*string', imports: [] })
+  })
+
+  it('returns interface{} for unknown types', () => {
+    expect(pgToGo('custom_enum', false)).toEqual({ type: 'interface{}', imports: [] })
+  })
+
+  it('maps bigint to int64', () => {
+    expect(pgToGo('bigint', false)).toEqual({ type: 'int64', imports: [] })
+  })
+
+  // Category-based mapping tests
+  it('maps string category to string', () => {
+    expect(pgToGo('custom_text', false, 'string')).toEqual({ type: 'string', imports: [] })
+  })
+
+  it('maps integer category to int64', () => {
+    expect(pgToGo('custom_int', false, 'integer')).toEqual({ type: 'int64', imports: [] })
+  })
+
+  it('maps time category to time.Time with import', () => {
+    expect(pgToGo('custom_ts', false, 'time')).toEqual({ type: 'time.Time', imports: ['time'] })
+  })
+
+  it('maps uuid category to uuid.UUID with import', () => {
+    expect(pgToGo('custom_uuid', false, 'uuid')).toEqual({ type: 'uuid.UUID', imports: ['github.com/google/uuid'] })
+  })
+
+  it('category with nullable uses pointer', () => {
+    expect(pgToGo('custom_int', true, 'integer')).toEqual({ type: '*int64', imports: [] })
+  })
+})
+
+describe('pgToPython', () => {
+  it('maps bigint to int', () => {
+    expect(pgToPython('bigint', false)).toBe('int')
+  })
+
+  it('maps timestamptz nullable to Optional[datetime]', () => {
+    expect(pgToPython('timestamptz', true)).toBe('Optional[datetime]')
+  })
+
+  it('maps text to str', () => {
+    expect(pgToPython('text', false)).toBe('str')
+  })
+
+  it('maps boolean to bool', () => {
+    expect(pgToPython('boolean', false)).toBe('bool')
+  })
+
+  it('maps jsonb to dict', () => {
+    expect(pgToPython('jsonb', false)).toBe('dict')
+  })
+
+  // Category-based mapping tests
+  it('maps string category to str', () => {
+    expect(pgToPython('custom_text', false, 'string')).toBe('str')
+  })
+
+  it('maps integer category to int', () => {
+    expect(pgToPython('custom_int', false, 'integer')).toBe('int')
+  })
+
+  it('maps decimal category to Decimal', () => {
+    expect(pgToPython('custom_num', false, 'decimal')).toBe('Decimal')
+  })
+
+  it('category with nullable uses Optional', () => {
+    expect(pgToPython('custom_int', true, 'integer')).toBe('Optional[int]')
+  })
+})
+
+describe('pgToJava', () => {
+  it('maps bigint to long', () => {
+    expect(pgToJava('bigint', false)).toEqual({ type: 'long', imports: [] })
+  })
+
+  it('maps uuid to UUID with import', () => {
+    expect(pgToJava('uuid', false)).toEqual({ type: 'UUID', imports: ['java.util.UUID'] })
+  })
+
+  it('maps text to String', () => {
+    expect(pgToJava('text', false)).toEqual({ type: 'String', imports: [] })
+  })
+
+  it('maps nullable bigint to Long wrapper', () => {
+    expect(pgToJava('bigint', true)).toEqual({ type: 'Long', imports: [] })
+  })
+
+  // Category-based mapping tests
+  it('maps string category to String', () => {
+    expect(pgToJava('custom_text', false, 'string')).toEqual({ type: 'String', imports: [] })
+  })
+
+  it('maps integer category to long', () => {
+    expect(pgToJava('custom_int', false, 'integer')).toEqual({ type: 'long', imports: [] })
+  })
+
+  it('maps decimal category to BigDecimal with import', () => {
+    expect(pgToJava('custom_num', false, 'decimal')).toEqual({ type: 'BigDecimal', imports: ['java.math.BigDecimal'] })
+  })
+
+  it('category integer nullable uses Long wrapper', () => {
+    expect(pgToJava('custom_int', true, 'integer')).toEqual({ type: 'Long', imports: [] })
+  })
+})
+
+describe('pgToKotlin', () => {
+  it('maps text nullable to String?', () => {
+    expect(pgToKotlin('text', true)).toBe('String?')
+  })
+
+  it('maps text non-nullable to String', () => {
+    expect(pgToKotlin('text', false)).toBe('String')
+  })
+
+  it('maps bigint to Long', () => {
+    expect(pgToKotlin('bigint', false)).toBe('Long')
+  })
+
+  // Category-based mapping tests
+  it('maps string category to String', () => {
+    expect(pgToKotlin('custom_text', false, 'string')).toBe('String')
+  })
+
+  it('maps integer category to Long', () => {
+    expect(pgToKotlin('custom_int', false, 'integer')).toBe('Long')
+  })
+
+  it('category with nullable uses ? suffix', () => {
+    expect(pgToKotlin('custom_int', true, 'integer')).toBe('Long?')
+  })
+})
+
+describe('pgToRust', () => {
+  it('maps bigint to i64', () => {
+    expect(pgToRust('bigint', false)).toEqual({ type: 'i64', imports: [] })
+  })
+
+  it('maps uuid to Uuid with import', () => {
+    expect(pgToRust('uuid', false)).toEqual({ type: 'Uuid', imports: ['uuid::Uuid'] })
+  })
+
+  it('maps nullable text to Option<String>', () => {
+    expect(pgToRust('text', true)).toEqual({ type: 'Option<String>', imports: [] })
+  })
+
+  // Category-based mapping tests
+  it('maps string category to String', () => {
+    expect(pgToRust('custom_text', false, 'string')).toEqual({ type: 'String', imports: [] })
+  })
+
+  it('maps integer category to i64', () => {
+    expect(pgToRust('custom_int', false, 'integer')).toEqual({ type: 'i64', imports: [] })
+  })
+
+  it('maps json category to serde_json::Value with import', () => {
+    expect(pgToRust('custom_json', false, 'json')).toEqual({
+      type: 'serde_json::Value',
+      imports: ['serde_json::Value'],
+    })
+  })
+
+  it('category with nullable uses Option', () => {
+    expect(pgToRust('custom_int', true, 'integer')).toEqual({ type: 'Option<i64>', imports: [] })
+  })
+})
+
+describe('pgToCsharp', () => {
+  it('maps timestamptz to DateTimeOffset', () => {
+    expect(pgToCsharp('timestamptz', false)).toBe('DateTimeOffset')
+  })
+
+  it('maps integer nullable to int?', () => {
+    expect(pgToCsharp('integer', true)).toBe('int?')
+  })
+
+  it('maps text to string', () => {
+    expect(pgToCsharp('text', false)).toBe('string')
+  })
+
+  it('maps boolean to bool', () => {
+    expect(pgToCsharp('boolean', false)).toBe('bool')
+  })
+
+  // Category-based mapping tests
+  it('maps string category to string', () => {
+    expect(pgToCsharp('custom_text', false, 'string')).toBe('string')
+  })
+
+  it('maps integer category to long', () => {
+    expect(pgToCsharp('custom_int', false, 'integer')).toBe('long')
+  })
+
+  it('maps uuid category to Guid', () => {
+    expect(pgToCsharp('custom_uuid', false, 'uuid')).toBe('Guid')
+  })
+
+  it('category with nullable uses ? suffix', () => {
+    expect(pgToCsharp('custom_int', true, 'integer')).toBe('long?')
+  })
+})

package/src/__tests__/typescript.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it } from 'vitest'
+import typescript from '../typescript/index.ts'
+
+const generate = typescript.generate
+
+import type { AtlasRealm } from '@sqldoc/atlas'
+import type { TemplateContext } from '@sqldoc/ns-codegen'
+
+const testRealm: AtlasRealm = {
+  schemas: [
+    {
+      name: 'public',
+      tables: [
+        {
+          name: 'users',
+          columns: [
+            { name: 'id', type: { T: 'bigserial', null: false, category: 'integer' } },
+            { name: 'email', type: { T: 'character varying', raw: 'varchar(255)', null: false, category: 'string' } },
+            { name: 'name', type: { T: 'text', null: true, category: 'string' } },
+            { name: 'age', type: { T: 'integer', null: true, category: 'integer' } },
+            { name: 'is_active', type: { T: 'boolean', null: false, category: 'boolean' } },
+            { name: 'metadata', type: { T: 'jsonb', null: true, category: 'json' } },
+            { name: 'created_at', type: { T: 'timestamp with time zone', null: false, category: 'time' } },
+            { name: 'tags', type: { T: 'text[]', null: true, category: 'array' } },
+            { name: 'avatar', type: { T: 'bytea', null: true, category: 'binary' } },
+            { name: 'balance', type: { T: 'numeric(10,2)', null: true, category: 'decimal' } },
+            { name: 'external_id', type: { T: 'uuid', null: true, category: 'uuid' } },
+          ],
+          primary_key: { parts: [{ column: 'id' }] },
+        },
+        {
+          name: 'posts',
+          columns: [
+            { name: 'id', type: { T: 'bigserial', null: false, category: 'integer' } },
+            { name: 'user_id', type: { T: 'bigint', null: false, category: 'integer' } },
+            { name: 'title', type: { T: 'text', null: false, category: 'string' } },
+            { name: 'body', type: { T: 'text', null: false, category: 'string' } },
+            { name: 'published_at', type: { T: 'timestamp with time zone', null: true, category: 'time' } },
+            { name: 'view_count', type: { T: 'integer', null: false, category: 'integer' } },
+            { name: 'rating', type: { T: 'double precision', null: true, category: 'float' } },
+          ],
+          primary_key: { parts: [{ column: 'id' }] },
+          foreign_keys: [
+            { symbol: 'posts_user_id_fkey', columns: ['user_id'], ref_table: 'users', ref_columns: ['id'] },
+          ],
+        },
+        {
+          name: 'comments',
+          columns: [
+            { name: 'id', type: { T: 'bigserial', null: false, category: 'integer' } },
+            { name: 'post_id', type: { T: 'bigint', null: false, category: 'integer' } },
+            { name: 'user_id', type: { T: 'bigint', null: false, category: 'integer' } },
+            { name: 'content', type: { T: 'text', null: false, category: 'string' } },
+            { name: 'created_at', type: { T: 'timestamp with time zone', null: false, category: 'time' } },
+          ],
+          primary_key: { parts: [{ column: 'id' }] },
+          foreign_keys: [
+            { symbol: 'comments_post_id_fkey', columns: ['post_id'], ref_table: 'posts', ref_columns: ['id'] },
+            { symbol: 'comments_user_id_fkey', columns: ['user_id'], ref_table: 'users', ref_columns: ['id'] },
+          ],
+        },
+      ],
+    },
+  ],
+}
+
+function makeCtx(overrides?: Partial<TemplateContext>): TemplateContext {
+  return {
+    realm: testRealm,
+    allFileTags: [],
+    docsMeta: [],
+    config: {},
+    output: './out',
+    templateName: 'typescript',
+    ...overrides,
+  }
+}
+
+describe('typescript template', () => {
+  it('generates interfaces for all tables', () => {
+    const result = generate(makeCtx())
+    expect(result.files).toHaveLength(1)
+    expect(result.files[0].path).toBe('models.ts')
+
+    const content = result.files[0].content
+    expect(content).toContain('export interface Users {')
+    expect(content).toContain('export interface Posts {')
+    expect(content).toContain('export interface Comments {')
+  })
+
+  it('maps bigserial to number', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('id: number')
+  })
+
+  it('uses optional (?) for nullable columns by default', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('name?: string')
+    expect(content).toContain('age?: number')
+  })
+
+  it('uses null-union style when configured', () => {
+    const result = generate(makeCtx({ config: { nullableStyle: 'null-union' } }))
+    const content = result.files[0].content
+    expect(content).toContain('name: string | null')
+    expect(content).toContain('age: number | null')
+  })
+
+  it('maps text[] to string[] array type', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('tags?: string[]')
+  })
+
+  it('maps jsonb to unknown', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('metadata?: unknown')
+  })
+
+  it('maps bytea to Buffer', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('avatar?: Buffer')
+  })
+
+  it('maps uuid to string', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('externalId?: string')
+  })
+
+  it('includes header comment', () => {
+    const result = generate(makeCtx())
+    const content = result.files[0].content
+    expect(content).toContain('// Generated by @sqldoc/templates/typescript -- DO NOT EDIT')
+  })
+
+  it('respects @codegen.skip tag', () => {
+    const ctx = makeCtx({
+      allFileTags: [
+        {
+          sourceFile: 'test.sql',
+          objects: [
+            {
+              objectName: 'comments',
+              target: 'table',
+              tags: [{ namespace: 'codegen', tag: 'skip', args: [] }],
+            },
+          ],
+        },
+      ],
+    })
+    const result = generate(ctx)
+    const content = result.files[0].content
+    expect(content).not.toContain('export interface Comments')
+    expect(content).toContain('export interface Users')
+  })
+
+  it('respects @codegen.rename tag', () => {
+    const ctx = makeCtx({
+      allFileTags: [
+        {
+          sourceFile: 'test.sql',
+          objects: [
+            {
+              objectName: 'users',
+              target: 'table',
+              tags: [{ namespace: 'codegen', tag: 'rename', args: ['Account'] }],
+            },
+          ],
+        },
+      ],
+    })
+    const result = generate(ctx)
+    const content = result.files[0].content
+    expect(content).toContain('export interface Account {')
+    expect(content).not.toContain('export interface Users {')
+  })
+
+  it('respects @codegen.type override on column', () => {
+    const ctx = makeCtx({
+      allFileTags: [
+        {
+          sourceFile: 'test.sql',
+          objects: [
+            {
+              objectName: 'users.metadata',
+              target: 'column',
+              tags: [{ namespace: 'codegen', tag: 'type', args: ['Record<string, any>'] }],
+            },
+          ],
+        },
+      ],
+    })
+    const result = generate(ctx)
+    const content = result.files[0].content
+    expect(content).toContain('metadata?: Record<string, any>')
+  })
+})