@sqldoc/templates 0.0.1 → 0.0.2

package/src/__tests__/rust-structs.test.ts

@@ -1,176 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import rustStructs from '../rust-structs/index'
-
-const generate = rustStructs.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: '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: 'timestamptz', 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: { name: 'users_pkey', 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: 'timestamptz', 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: { name: 'posts_pkey', parts: [{ column: 'id' }] },
-          foreign_keys: [
-            { symbol: 'posts_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: './generated',
-    templateName: 'rust-structs',
-    ...overrides,
-  }
-}
-
-describe('rust-structs template', () => {
-  it('generates valid Rust structs', () => {
-    const result = generate(makeCtx())
-    expect(result.files).toHaveLength(1)
-    expect(result.files[0].path).toBe('models.rs')
-  })
-
-  it('contains pub struct Users', () => {
-    const result = generate(makeCtx())
-    expect(result.files[0].content).toContain('pub struct Users {')
-  })
-
-  it('maps bigserial to i64', () => {
-    const result = generate(makeCtx())
-    expect(result.files[0].content).toContain('pub id: i64')
-  })
-
-  it('maps nullable text to Option<String>', () => {
-    const result = generate(makeCtx())
-    expect(result.files[0].content).toContain('pub name: Option<String>')
-  })
-
-  it('maps nullable text[] to Option<Vec<String>>', () => {
-    const result = generate(makeCtx())
-    expect(result.files[0].content).toContain('pub tags: Option<Vec<String>>')
-  })
-
-  it('includes chrono use statement for timestamptz', () => {
-    const result = generate(makeCtx())
-    expect(result.files[0].content).toContain('use chrono::')
-  })
-
-  it('includes serde derives', () => {
-    const result = generate(makeCtx())
-    expect(result.files[0].content).toContain('#[derive(Debug, Clone, Serialize, Deserialize)]')
-  })
-
-  it('includes use serde statement', () => {
-    const result = generate(makeCtx())
-    expect(result.files[0].content).toContain('use serde::{Serialize, Deserialize};')
-  })
-
-  it('generates Posts struct with correct types', () => {
-    const result = generate(makeCtx())
-    const content = result.files[0].content
-    expect(content).toContain('pub struct Posts {')
-    expect(content).toContain('pub user_id: i64')
-    expect(content).toContain('pub rating: Option<f64>')
-  })
-
-  it('skips tables with @codegen.skip', () => {
-    const result = generate(
-      makeCtx({
-        allFileTags: [
-          {
-            sourceFile: 'test.sql',
-            objects: [
-              {
-                objectName: 'users',
-                target: 'table',
-                tags: [{ namespace: 'codegen', tag: 'skip', args: [] }],
-              },
-            ],
-          },
-        ],
-      }),
-    )
-    const content = result.files[0].content
-    expect(content).not.toContain('pub struct Users')
-    expect(content).toContain('pub struct Posts')
-  })
-
-  it('applies @codegen.rename to struct name', () => {
-    const result = generate(
-      makeCtx({
-        allFileTags: [
-          {
-            sourceFile: 'test.sql',
-            objects: [
-              {
-                objectName: 'users',
-                target: 'table',
-                tags: [{ namespace: 'codegen', tag: 'rename', args: ['Account'] }],
-              },
-            ],
-          },
-        ],
-      }),
-    )
-    expect(result.files[0].content).toContain('pub struct Account {')
-    expect(result.files[0].content).not.toContain('pub struct Users')
-  })
-
-  it('applies @codegen.type override on a column', () => {
-    const result = generate(
-      makeCtx({
-        allFileTags: [
-          {
-            sourceFile: 'test.sql',
-            objects: [
-              {
-                objectName: 'users.metadata',
-                target: 'column',
-                tags: [{ namespace: 'codegen', tag: 'type', args: ['MyCustomType'] }],
-              },
-            ],
-          },
-        ],
-      }),
-    )
-    expect(result.files[0].content).toContain('pub metadata: Option<MyCustomType>')
-  })
-})

package/src/__tests__/tags-helpers.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { findRename, findTypeOverride, isSkipped } from '../helpers/tags'
-
-describe('findRename', () => {
-  it('returns undefined when no rename tag exists', () => {
-    const tags = [{ namespace: 'codegen', tag: 'skip', args: [] }]
-    expect(findRename(tags, 'typescript')).toBeUndefined()
-  })
-
-  it('returns global rename when no template-specific exists', () => {
-    const tags = [{ namespace: 'codegen', tag: 'rename', args: ['UserAccount'] }]
-    expect(findRename(tags, 'typescript')).toBe('UserAccount')
-  })
-
-  it('returns template-specific rename over global', () => {
-    const tags = [
-      { namespace: 'codegen', tag: 'rename', args: ['UserAccount'] },
-      { namespace: 'codegen', tag: 'rename', args: ['UserModel', 'typescript'] },
-    ]
-    expect(findRename(tags, 'typescript')).toBe('UserModel')
-  })
-
-  it('returns global rename for different template', () => {
-    const tags = [
-      { namespace: 'codegen', tag: 'rename', args: ['UserAccount'] },
-      { namespace: 'codegen', tag: 'rename', args: ['UserModel', 'typescript'] },
-    ]
-    expect(findRename(tags, 'go-structs')).toBe('UserAccount')
-  })
-})
-
-describe('isSkipped', () => {
-  it('returns false when no skip tag exists', () => {
-    const tags = [{ namespace: 'codegen', tag: 'rename', args: ['Foo'] }]
-    expect(isSkipped(tags, 'typescript')).toBe(false)
-  })
-
-  it('returns true for global skip (no args)', () => {
-    const tags = [{ namespace: 'codegen', tag: 'skip', args: [] }]
-    expect(isSkipped(tags, 'typescript')).toBe(true)
-  })
-
-  it('returns true for template-specific skip', () => {
-    const tags = [{ namespace: 'codegen', tag: 'skip', args: ['typescript'] }]
-    expect(isSkipped(tags, 'typescript')).toBe(true)
-  })
-
-  it('returns false for skip targeting different template', () => {
-    const tags = [{ namespace: 'codegen', tag: 'skip', args: ['go-structs'] }]
-    expect(isSkipped(tags, 'typescript')).toBe(false)
-  })
-})
-
-describe('findTypeOverride', () => {
-  it('returns undefined when no type tag exists', () => {
-    const tags = [{ namespace: 'codegen', tag: 'rename', args: ['Foo'] }]
-    expect(findTypeOverride(tags, 'typescript')).toBeUndefined()
-  })
-
-  it('returns global type override', () => {
-    const tags = [{ namespace: 'codegen', tag: 'type', args: ['CustomType'] }]
-    expect(findTypeOverride(tags, 'typescript')).toBe('CustomType')
-  })
-
-  it('returns template-specific type over global', () => {
-    const tags = [
-      { namespace: 'codegen', tag: 'type', args: ['GlobalType'] },
-      { namespace: 'codegen', tag: 'type', args: ['TsType', 'typescript'] },
-    ]
-    expect(findTypeOverride(tags, 'typescript')).toBe('TsType')
-  })
-})

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

@@ -1,332 +0,0 @@
-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?')
-  })
-})