@sqldoc/templates 0.0.1

package/src/types/pg-to-java.ts

@@ -0,0 +1,141 @@
+/** Category-based mapping — used when Atlas provides a type category */
+const CATEGORY_TO_JAVA: Record<string, [string, string | null]> = {
+  string: ['String', null],
+  integer: ['long', null],
+  float: ['double', null],
+  decimal: ['BigDecimal', 'java.math.BigDecimal'],
+  boolean: ['boolean', null],
+  time: ['LocalDateTime', 'java.time.LocalDateTime'],
+  binary: ['byte[]', null],
+  json: ['String', null],
+  uuid: ['UUID', 'java.util.UUID'],
+  spatial: ['String', null],
+  enum: ['String', null], // overridden per-column with actual enum type
+  unknown: ['Object', null],
+}
+
+// Java uses wrapper types for nullable primitives
+const PG_TO_JAVA: Record<string, [string, string | null]> = {
+  // [javaType, importPath] -- primitive types have wrapper equivalents for nullable
+  // Numeric
+  smallint: ['short', null],
+  int2: ['short', null],
+  integer: ['int', null],
+  int: ['int', null],
+  int4: ['int', null],
+  bigint: ['long', null],
+  int8: ['long', null],
+  serial: ['int', null],
+  serial4: ['int', null],
+  bigserial: ['long', null],
+  serial8: ['long', null],
+  smallserial: ['short', null],
+  serial2: ['short', null],
+  real: ['float', null],
+  float4: ['float', null],
+  'double precision': ['double', null],
+  float8: ['double', null],
+  numeric: ['BigDecimal', 'java.math.BigDecimal'],
+  decimal: ['BigDecimal', 'java.math.BigDecimal'],
+  money: ['BigDecimal', 'java.math.BigDecimal'],
+
+  // String
+  text: ['String', null],
+  varchar: ['String', null],
+  'character varying': ['String', null],
+  char: ['String', null],
+  character: ['String', null],
+  name: ['String', null],
+  citext: ['String', null],
+
+  // Boolean
+  boolean: ['boolean', null],
+  bool: ['boolean', null],
+
+  // Date/Time
+  timestamp: ['LocalDateTime', 'java.time.LocalDateTime'],
+  'timestamp without time zone': ['LocalDateTime', 'java.time.LocalDateTime'],
+  timestamptz: ['OffsetDateTime', 'java.time.OffsetDateTime'],
+  'timestamp with time zone': ['OffsetDateTime', 'java.time.OffsetDateTime'],
+  date: ['LocalDate', 'java.time.LocalDate'],
+  time: ['LocalTime', 'java.time.LocalTime'],
+  'time without time zone': ['LocalTime', 'java.time.LocalTime'],
+  timetz: ['LocalTime', 'java.time.LocalTime'],
+  'time with time zone': ['LocalTime', 'java.time.LocalTime'],
+  interval: ['Duration', 'java.time.Duration'],
+
+  // Binary
+  bytea: ['byte[]', null],
+
+  // JSON
+  json: ['String', null],
+  jsonb: ['String', null],
+
+  // UUID
+  uuid: ['UUID', 'java.util.UUID'],
+
+  // Network
+  inet: ['String', null],
+  cidr: ['String', null],
+  macaddr: ['String', null],
+}
+
+// Mapping from primitive types to their wrapper types for nullable
+const PRIMITIVE_TO_WRAPPER: Record<string, string> = {
+  short: 'Short',
+  int: 'Integer',
+  long: 'Long',
+  float: 'Float',
+  double: 'Double',
+  boolean: 'Boolean',
+  'byte[]': 'byte[]',
+}
+
+/**
+ * Map a PostgreSQL type to a Java type and required imports.
+ * Nullable primitive types use their wrapper equivalents (int -> Integer, long -> Long).
+ */
+export function pgToJava(pgType: string, nullable: boolean, category?: string): { type: string; imports: string[] } {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]')) {
+    const base = pgToJava(normalized.slice(0, -2), false)
+    const wrappedType = PRIMITIVE_TO_WRAPPER[base.type] ?? base.type
+    const imports = [...base.imports]
+    if (!imports.includes('java.util.List')) imports.push('java.util.List')
+    return { type: `List<${wrappedType}>`, imports }
+  }
+  if (normalized.startsWith('_')) {
+    const base = pgToJava(normalized.slice(1), false)
+    const wrappedType = PRIMITIVE_TO_WRAPPER[base.type] ?? base.type
+    const imports = [...base.imports]
+    if (!imports.includes('java.util.List')) imports.push('java.util.List')
+    return { type: `List<${wrappedType}>`, imports }
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  // Try raw type lookup first for precise mapping
+  let mapping = PG_TO_JAVA[baseType]
+
+  // Fall back to category-based mapping for unknown raw types
+  if (!mapping && category) {
+    mapping = CATEGORY_TO_JAVA[category]
+  }
+
+  if (!mapping) return { type: 'Object', imports: [] }
+
+  const [javaType, importPath] = mapping
+  const imports = importPath ? [importPath] : []
+
+  if (nullable) {
+    const wrapper = PRIMITIVE_TO_WRAPPER[javaType]
+    if (wrapper) {
+      return { type: wrapper, imports }
+    }
+  }
+
+  return { type: javaType, imports }
+}

package/src/types/pg-to-kotlin.ts

@@ -0,0 +1,119 @@
+/** Category-based mapping — used when Atlas provides a type category */
+const CATEGORY_TO_KOTLIN: Record<string, string> = {
+  string: 'String',
+  integer: 'Long',
+  float: 'Double',
+  decimal: 'BigDecimal',
+  boolean: 'Boolean',
+  time: 'LocalDateTime',
+  binary: 'ByteArray',
+  json: 'String',
+  uuid: 'UUID',
+  spatial: 'String',
+  enum: 'String', // overridden per-column with actual enum type
+  unknown: 'String',
+}
+
+const PG_TO_KOTLIN: Record<string, string> = {
+  // Numeric
+  smallint: 'Short',
+  int2: 'Short',
+  integer: 'Int',
+  int: 'Int',
+  int4: 'Int',
+  bigint: 'Long',
+  int8: 'Long',
+  serial: 'Int',
+  serial4: 'Int',
+  bigserial: 'Long',
+  serial8: 'Long',
+  smallserial: 'Short',
+  serial2: 'Short',
+  real: 'Float',
+  float4: 'Float',
+  'double precision': 'Double',
+  float8: 'Double',
+  numeric: 'BigDecimal',
+  decimal: 'BigDecimal',
+  money: 'BigDecimal',
+
+  // String
+  text: 'String',
+  varchar: 'String',
+  'character varying': 'String',
+  char: 'String',
+  character: 'String',
+  name: 'String',
+  citext: 'String',
+
+  // Boolean
+  boolean: 'Boolean',
+  bool: 'Boolean',
+
+  // Date/Time
+  timestamp: 'LocalDateTime',
+  'timestamp without time zone': 'LocalDateTime',
+  timestamptz: 'OffsetDateTime',
+  'timestamp with time zone': 'OffsetDateTime',
+  date: 'LocalDate',
+  time: 'LocalTime',
+  'time without time zone': 'LocalTime',
+  timetz: 'LocalTime',
+  'time with time zone': 'LocalTime',
+  interval: 'Duration',
+
+  // Binary
+  bytea: 'ByteArray',
+
+  // JSON
+  json: 'String',
+  jsonb: 'String',
+
+  // UUID
+  uuid: 'UUID',
+
+  // Network
+  inet: 'String',
+  cidr: 'String',
+  macaddr: 'String',
+}
+
+/**
+ * Map a PostgreSQL type to a Kotlin type string.
+ * Nullable types use Kotlin's ? suffix: String -> String?
+ */
+export function pgToKotlin(pgType: string, nullable: boolean, category?: string): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]')) {
+    const base = pgToKotlin(normalized.slice(0, -2), false)
+    return wrapNullable(`List<${base}>`, nullable)
+  }
+  if (normalized.startsWith('_')) {
+    const base = pgToKotlin(normalized.slice(1), false)
+    return wrapNullable(`List<${base}>`, nullable)
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  // Try raw type lookup first for precise mapping
+  let ktType = PG_TO_KOTLIN[baseType]
+
+  // Fall back to category-based mapping for unknown raw types
+  if (ktType === undefined && category) {
+    ktType = CATEGORY_TO_KOTLIN[category]
+  }
+
+  if (ktType === undefined) {
+    ktType = 'String'
+  }
+
+  return wrapNullable(ktType, nullable)
+}
+
+function wrapNullable(type: string, nullable: boolean): string {
+  if (!nullable) return type
+  return `${type}?`
+}

package/src/types/pg-to-python.ts

@@ -0,0 +1,120 @@
+/** Category-based mapping — used when Atlas provides a type category */
+const CATEGORY_TO_PYTHON: Record<string, string> = {
+  string: 'str',
+  integer: 'int',
+  float: 'float',
+  decimal: 'Decimal',
+  boolean: 'bool',
+  time: 'datetime',
+  binary: 'bytes',
+  json: 'dict',
+  uuid: 'UUID',
+  spatial: 'str',
+  enum: 'str', // overridden per-column with actual enum type
+  unknown: 'Any',
+}
+
+const PG_TO_PYTHON: Record<string, string> = {
+  // Numeric
+  smallint: 'int',
+  int2: 'int',
+  integer: 'int',
+  int: 'int',
+  int4: 'int',
+  bigint: 'int',
+  int8: 'int',
+  serial: 'int',
+  serial4: 'int',
+  bigserial: 'int',
+  serial8: 'int',
+  smallserial: 'int',
+  serial2: 'int',
+  real: 'float',
+  float4: 'float',
+  'double precision': 'float',
+  float8: 'float',
+  numeric: 'Decimal',
+  decimal: 'Decimal',
+  money: 'Decimal',
+
+  // String
+  text: 'str',
+  varchar: 'str',
+  'character varying': 'str',
+  char: 'str',
+  character: 'str',
+  name: 'str',
+  citext: 'str',
+
+  // Boolean
+  boolean: 'bool',
+  bool: 'bool',
+
+  // Date/Time
+  timestamp: 'datetime',
+  'timestamp without time zone': 'datetime',
+  timestamptz: 'datetime',
+  'timestamp with time zone': 'datetime',
+  date: 'date',
+  time: 'time',
+  'time without time zone': 'time',
+  timetz: 'time',
+  'time with time zone': 'time',
+  interval: 'timedelta',
+
+  // Binary
+  bytea: 'bytes',
+
+  // JSON
+  json: 'dict',
+  jsonb: 'dict',
+
+  // UUID
+  uuid: 'UUID',
+
+  // Network
+  inet: 'str',
+  cidr: 'str',
+  macaddr: 'str',
+  macaddr8: 'str',
+}
+
+/**
+ * Map a PostgreSQL type to a Python type annotation.
+ * Nullable types use Optional[T].
+ */
+export function pgToPython(pgType: string, nullable: boolean, category?: string): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]')) {
+    const base = pgToPython(normalized.slice(0, -2), false)
+    return wrapNullable(`list[${base}]`, nullable)
+  }
+  if (normalized.startsWith('_')) {
+    const base = pgToPython(normalized.slice(1), false)
+    return wrapNullable(`list[${base}]`, nullable)
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  // Try raw type lookup first for precise mapping
+  let pyType = PG_TO_PYTHON[baseType]
+
+  // Fall back to category-based mapping for unknown raw types
+  if (pyType === undefined && category) {
+    pyType = CATEGORY_TO_PYTHON[category]
+  }
+
+  if (pyType === undefined) {
+    pyType = 'Any'
+  }
+
+  return wrapNullable(pyType, nullable)
+}
+
+function wrapNullable(type: string, nullable: boolean): string {
+  if (!nullable) return type
+  return `Optional[${type}]`
+}

package/src/types/pg-to-rust.ts

@@ -0,0 +1,121 @@
+/** Category-based mapping — used when Atlas provides a type category */
+const CATEGORY_TO_RUST: Record<string, [string, string | null]> = {
+  string: ['String', null],
+  integer: ['i64', null],
+  float: ['f64', null],
+  decimal: ['bigdecimal::BigDecimal', 'bigdecimal::BigDecimal'],
+  boolean: ['bool', null],
+  time: ['NaiveDateTime', 'chrono::NaiveDateTime'],
+  binary: ['Vec<u8>', null],
+  json: ['serde_json::Value', 'serde_json::Value'],
+  uuid: ['Uuid', 'uuid::Uuid'],
+  spatial: ['String', null],
+  enum: ['String', null], // overridden per-column with actual enum type
+  unknown: ['String', null],
+}
+
+const PG_TO_RUST: Record<string, [string, string | null]> = {
+  // [rustType, importPath]
+  // Numeric
+  smallint: ['i16', null],
+  int2: ['i16', null],
+  integer: ['i32', null],
+  int: ['i32', null],
+  int4: ['i32', null],
+  bigint: ['i64', null],
+  int8: ['i64', null],
+  serial: ['i32', null],
+  serial4: ['i32', null],
+  bigserial: ['i64', null],
+  serial8: ['i64', null],
+  smallserial: ['i16', null],
+  serial2: ['i16', null],
+  real: ['f32', null],
+  float4: ['f32', null],
+  'double precision': ['f64', null],
+  float8: ['f64', null],
+  numeric: ['bigdecimal::BigDecimal', 'bigdecimal::BigDecimal'],
+  decimal: ['bigdecimal::BigDecimal', 'bigdecimal::BigDecimal'],
+  money: ['String', null],
+
+  // String
+  text: ['String', null],
+  varchar: ['String', null],
+  'character varying': ['String', null],
+  char: ['String', null],
+  character: ['String', null],
+  name: ['String', null],
+  citext: ['String', null],
+
+  // Boolean
+  boolean: ['bool', null],
+  bool: ['bool', null],
+
+  // Date/Time
+  timestamp: ['NaiveDateTime', 'chrono::NaiveDateTime'],
+  'timestamp without time zone': ['NaiveDateTime', 'chrono::NaiveDateTime'],
+  timestamptz: ['DateTime<Utc>', 'chrono::{DateTime, Utc}'],
+  'timestamp with time zone': ['DateTime<Utc>', 'chrono::{DateTime, Utc}'],
+  date: ['NaiveDate', 'chrono::NaiveDate'],
+  time: ['NaiveTime', 'chrono::NaiveTime'],
+  'time without time zone': ['NaiveTime', 'chrono::NaiveTime'],
+  timetz: ['NaiveTime', 'chrono::NaiveTime'],
+  'time with time zone': ['NaiveTime', 'chrono::NaiveTime'],
+  interval: ['PgInterval', null],
+
+  // Binary
+  bytea: ['Vec<u8>', null],
+
+  // JSON
+  json: ['serde_json::Value', 'serde_json::Value'],
+  jsonb: ['serde_json::Value', 'serde_json::Value'],
+
+  // UUID
+  uuid: ['Uuid', 'uuid::Uuid'],
+
+  // Network
+  inet: ['String', null],
+  cidr: ['String', null],
+  macaddr: ['String', null],
+}
+
+/**
+ * Map a PostgreSQL type to a Rust type and required imports.
+ * Nullable types use Option<T>.
+ */
+export function pgToRust(pgType: string, nullable: boolean, category?: string): { type: string; imports: string[] } {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays
+  if (normalized.endsWith('[]')) {
+    const base = pgToRust(normalized.slice(0, -2), false)
+    const vecType = `Vec<${base.type}>`
+    return nullable ? { type: `Option<${vecType}>`, imports: base.imports } : { type: vecType, imports: base.imports }
+  }
+  if (normalized.startsWith('_')) {
+    const base = pgToRust(normalized.slice(1), false)
+    const vecType = `Vec<${base.type}>`
+    return nullable ? { type: `Option<${vecType}>`, imports: base.imports } : { type: vecType, imports: base.imports }
+  }
+
+  // Strip length specifiers
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  // Try raw type lookup first for precise mapping
+  let mapping = PG_TO_RUST[baseType]
+
+  // Fall back to category-based mapping for unknown raw types
+  if (!mapping && category) {
+    mapping = CATEGORY_TO_RUST[category]
+  }
+
+  if (!mapping) return { type: 'String', imports: [] }
+
+  const [rustType, importPath] = mapping
+  const imports = importPath ? [importPath] : []
+
+  if (nullable) {
+    return { type: `Option<${rustType}>`, imports }
+  }
+  return { type: rustType, imports }
+}

package/src/types/pg-to-ts.ts

@@ -0,0 +1,173 @@
+export interface TsTypeOptions {
+  dateType?: 'Date' | 'temporal' | 'dayjs' | 'luxon' | 'string'
+  nullableStyle?: 'optional' | 'null-union'
+  bigintType?: 'number' | 'bigint' | 'string'
+}
+
+/** Category-based mapping — used when Atlas provides a type category */
+const CATEGORY_TO_TS: Record<string, string> = {
+  string: 'string',
+  integer: 'number',
+  float: 'number',
+  decimal: 'string',
+  boolean: 'boolean',
+  time: 'Date',
+  binary: 'Buffer',
+  json: 'unknown',
+  uuid: 'string',
+  spatial: 'string',
+  enum: 'string', // overridden per-column with actual enum type
+  unknown: 'unknown',
+}
+
+const PG_TO_TS: Record<string, string> = {
+  // Numeric
+  smallint: 'number',
+  int2: 'number',
+  integer: 'number',
+  int: 'number',
+  int4: 'number',
+  bigint: 'number',
+  int8: 'number',
+  serial: 'number',
+  serial4: 'number',
+  bigserial: 'number',
+  serial8: 'number',
+  smallserial: 'number',
+  serial2: 'number',
+  real: 'number',
+  float4: 'number',
+  'double precision': 'number',
+  float8: 'number',
+  numeric: 'string',
+  decimal: 'string',
+  money: 'string',
+
+  // String
+  text: 'string',
+  varchar: 'string',
+  'character varying': 'string',
+  char: 'string',
+  character: 'string',
+  name: 'string',
+  citext: 'string',
+
+  // Boolean
+  boolean: 'boolean',
+  bool: 'boolean',
+
+  // Date/Time
+  timestamp: 'Date',
+  'timestamp without time zone': 'Date',
+  timestamptz: 'Date',
+  'timestamp with time zone': 'Date',
+  date: 'string',
+  time: 'string',
+  'time without time zone': 'string',
+  timetz: 'string',
+  'time with time zone': 'string',
+  interval: 'string',
+
+  // Binary
+  bytea: 'Buffer',
+
+  // JSON
+  json: 'unknown',
+  jsonb: 'unknown',
+
+  // UUID
+  uuid: 'string',
+
+  // Network
+  inet: 'string',
+  cidr: 'string',
+  macaddr: 'string',
+  macaddr8: 'string',
+
+  // Geometric
+  point: 'string',
+  line: 'string',
+  box: 'string',
+  circle: 'string',
+  polygon: 'string',
+  path: 'string',
+
+  // Other
+  xml: 'string',
+  tsvector: 'string',
+  tsquery: 'string',
+  oid: 'number',
+}
+
+/** Temporal API mappings — each SQL date/time type maps to the right Temporal type */
+const TEMPORAL_MAP: Record<string, string> = {
+  date: 'Temporal.PlainDate',
+  timestamp: 'Temporal.PlainDateTime',
+  'timestamp without time zone': 'Temporal.PlainDateTime',
+  timestamptz: 'Temporal.ZonedDateTime',
+  'timestamp with time zone': 'Temporal.ZonedDateTime',
+  time: 'Temporal.PlainTime',
+  'time without time zone': 'Temporal.PlainTime',
+  timetz: 'string',
+  'time with time zone': 'string',
+  interval: 'Temporal.Duration',
+}
+
+/**
+ * Map a PostgreSQL type to a TypeScript type string.
+ * Handles arrays (text[], _text), length specifiers (varchar(255)), and nullability.
+ */
+export function pgToTs(pgType: string, nullable: boolean, options: TsTypeOptions = {}, category?: string): string {
+  const normalized = pgType.toLowerCase().trim()
+
+  // Handle arrays: text[] or _text
+  if (normalized.endsWith('[]')) {
+    const base = pgToTs(normalized.slice(0, -2), false, options)
+    return wrapNullable(`${base}[]`, nullable, options.nullableStyle)
+  }
+  if (normalized.startsWith('_')) {
+    const base = pgToTs(normalized.slice(1), false, options)
+    return wrapNullable(`${base}[]`, nullable, options.nullableStyle)
+  }
+
+  // Strip length specifiers: varchar(255) -> varchar, numeric(10,2) -> numeric
+  const baseType = normalized.replace(/\(\d+(?:,\s*\d+)?\)/, '').trim()
+
+  // Try raw type lookup first for precise mapping
+  let tsType = PG_TO_TS[baseType]
+
+  // Fall back to category-based mapping for unknown raw types
+  if (tsType === undefined && category) {
+    tsType = CATEGORY_TO_TS[category]
+  }
+
+  if (tsType === undefined) {
+    tsType = 'unknown'
+  }
+
+  // Apply bigintType option
+  if (
+    (baseType === 'bigint' || baseType === 'int8' || baseType === 'bigserial' || baseType === 'serial8') &&
+    options.bigintType
+  ) {
+    tsType = options.bigintType
+  }
+
+  // Apply dateType option
+  if (options.dateType === 'temporal') {
+    const temporal = TEMPORAL_MAP[baseType]
+    if (temporal) tsType = temporal
+  } else if (options.dateType && options.dateType !== 'Date') {
+    if (tsType === 'Date') {
+      tsType = options.dateType === 'string' ? 'string' : `import('${options.dateType}').Dayjs`
+    }
+  }
+
+  return wrapNullable(tsType, nullable, options.nullableStyle)
+}
+
+function wrapNullable(type: string, nullable: boolean, style?: 'optional' | 'null-union'): string {
+  if (!nullable) return type
+  if (style === 'null-union') return `${type} | null`
+  return type // 'optional' style is handled at property level with ?:
+}