@sqldoc/templates 0.0.1

package/src/helpers/enrich.ts

@@ -0,0 +1,396 @@
+/**
+ * Enrichment layer — preprocesses Atlas realm + tags into a rich,
+ * template-friendly structure. Computed once, used by all templates.
+ */
+import type { AtlasColumn, AtlasTable, TypeCategory } from '@sqldoc/atlas'
+import type { TemplateContext } from '@sqldoc/ns-codegen'
+import { findTagsForObject, getColumnType, getTablesFromRealm, getViewsFromRealm, isNullable } from './atlas.ts'
+import { toPascalCase } from './naming.ts'
+import { findRename, findTypeOverride, isSkipped } from './tags.ts'
+
+// ── Public types ─────────────────────────────────────────────────
+
+export interface EnrichedSchema {
+  tables: EnrichedTable[]
+  views: EnrichedView[]
+  enums: EnrichedEnum[]
+  functions: EnrichedFunction[]
+}
+
+export interface EnrichedTable {
+  /** Original SQL name */
+  name: string
+  /** PascalCase name (or @codegen.rename override) */
+  pascalName: string
+  /** Whether this table is skipped for the current template */
+  skipped: boolean
+  /** Column definitions */
+  columns: EnrichedColumn[]
+  /** Primary key column names */
+  primaryKey: string[]
+  /** FKs on this table pointing to other tables */
+  belongsTo: Relation[]
+  /** FKs on other tables pointing to this table */
+  hasMany: Relation[]
+  /** All tags on this table */
+  tags: TagEntry[]
+  /** Raw Atlas table (escape hatch) */
+  raw: AtlasTable
+}
+
+export interface EnrichedColumn {
+  /** Original SQL name */
+  name: string
+  /** PascalCase name */
+  pascalName: string
+  /** camelCase name */
+  camelName: string
+  /** Raw SQL type string (e.g. "character varying", "bigserial") */
+  pgType: string
+  /** Dialect-independent type category from Atlas */
+  category: TypeCategory
+  /** Whether this is a user-defined type (enum, composite, domain) */
+  isCustomType: boolean
+  /** Enum values (when category is 'enum') */
+  enumValues?: string[]
+  /** Composite type fields (when category is 'composite') */
+  compositeFields?: Array<{ name: string; type: string }>
+  /** Whether the column is nullable */
+  nullable: boolean
+  /** Whether this is a primary key column */
+  isPrimaryKey: boolean
+  /** Whether this is a serial/auto-increment column */
+  isSerial: boolean
+  /** Default value expression (if any) */
+  defaultValue?: string
+  /** FK reference (if this column is a foreign key) */
+  foreignKey?: { table: string; column: string }
+  /** Type override from @codegen.type tag (if any) */
+  typeOverride?: string
+  /** All tags on this column */
+  tags: TagEntry[]
+  /** Raw Atlas column (escape hatch) */
+  raw: AtlasColumn
+}
+
+export interface Relation {
+  /** Constraint name */
+  constraintName: string
+  /** Column on the source table */
+  column: string
+  /** The other table */
+  foreignTable: string
+  /** Column on the other table */
+  foreignColumn: string
+}
+
+export interface TagEntry {
+  namespace: string
+  tag: string | null
+  args: Record<string, unknown> | unknown[]
+}
+
+export interface EnrichedView {
+  /** Original SQL name */
+  name: string
+  /** PascalCase name */
+  pascalName: string
+  /** Whether this view is skipped for the current template */
+  skipped: boolean
+  /** Column definitions (no PK, FK, or serial) */
+  columns: EnrichedColumn[]
+  /** All tags on this view */
+  tags: TagEntry[]
+}
+
+export interface EnrichedEnum {
+  /** Original SQL type name */
+  name: string
+  /** PascalCase name */
+  pascalName: string
+  /** Enum variant values */
+  values: string[]
+}
+
+export interface EnrichedFunction {
+  /** Original SQL function name */
+  name: string
+  /** PascalCase name */
+  pascalName: string
+  /** Function arguments */
+  args: Array<{ name: string; type: string; category: string }>
+  /** Return type */
+  returnType?: { type: string; category: string }
+  /** Language (sql, plpgsql, etc.) */
+  language?: string
+}
+
+// ── Enrichment ───────────────────────────────────────────────────
+
+/**
+ * Enrich the raw Atlas realm into a template-friendly structure.
+ * Computes relationships, PK/FK lookups, tag indexing, naming, etc.
+ */
+export function enrichRealm(ctx: TemplateContext<any>): EnrichedSchema {
+  const rawTables = getTablesFromRealm(ctx.realm)
+
+  // Build reverse FK index: targetTable → relations pointing at it
+  const reverseIndex = new Map<string, Relation[]>()
+  for (const table of rawTables) {
+    for (const fk of table.foreign_keys ?? []) {
+      if (!fk.ref_table || !fk.columns?.length) continue
+      for (let i = 0; i < fk.columns.length; i++) {
+        const rel: Relation = {
+          constraintName: fk.symbol ?? '',
+          column: fk.ref_columns?.[i] ?? 'id',
+          foreignTable: table.name,
+          foreignColumn: fk.columns[i],
+        }
+        const existing = reverseIndex.get(fk.ref_table) ?? []
+        existing.push(rel)
+        reverseIndex.set(fk.ref_table, existing)
+      }
+    }
+  }
+
+  const tables: EnrichedTable[] = rawTables.map((table) => {
+    const tableTags = findTagsForObject(ctx.allFileTags, table.name)
+    const skipped = isSkipped(tableTags, ctx.templateName)
+    const pascalName = findRename(tableTags, ctx.templateName) ?? toPascalCase(table.name)
+    const pkColumns = new Set(
+      (table.primary_key?.parts ?? []).map((p) => p.column).filter((c): c is string => c != null),
+    )
+
+    // Build FK map for this table
+    const fkMap = new Map<string, { table: string; column: string }>()
+    const belongsTo: Relation[] = []
+    for (const fk of table.foreign_keys ?? []) {
+      if (!fk.columns?.length || !fk.ref_table) continue
+      for (let i = 0; i < fk.columns.length; i++) {
+        const ref = { table: fk.ref_table, column: fk.ref_columns?.[i] ?? 'id' }
+        fkMap.set(fk.columns[i], ref)
+        belongsTo.push({
+          constraintName: fk.symbol ?? '',
+          column: fk.columns[i],
+          foreignTable: fk.ref_table,
+          foreignColumn: ref.column,
+        })
+      }
+    }
+
+    const hasMany = reverseIndex.get(table.name) ?? []
+
+    const columns: EnrichedColumn[] = (table.columns ?? []).map((col) =>
+      enrichColumn(col, table.name, ctx.templateName, ctx.allFileTags, pkColumns, fkMap),
+    )
+
+    return {
+      name: table.name,
+      pascalName,
+      skipped,
+      columns,
+      primaryKey: [...pkColumns],
+      belongsTo,
+      hasMany,
+      tags: tableTags,
+      raw: table,
+    }
+  })
+
+  // ── Views ──────────────────────────────────────────────────────
+  const rawViews = getViewsFromRealm(ctx.realm)
+  const views: EnrichedView[] = rawViews.map((view) => {
+    const viewTags = findTagsForObject(ctx.allFileTags, view.name)
+    const skipped = isSkipped(viewTags, ctx.templateName)
+    const pascalName = findRename(viewTags, ctx.templateName) ?? toPascalCase(view.name)
+
+    let columns: EnrichedColumn[]
+    if (view.columns?.length) {
+      // Atlas provided column metadata
+      columns = view.columns.map((col) => enrichColumn(col, view.name, ctx.templateName, ctx.allFileTags))
+    } else if (view.def) {
+      // Atlas didn't provide columns — resolve from the SELECT list + source tables
+      columns = resolveViewColumns(view.def, tables, view.name, ctx.templateName, ctx.allFileTags)
+    } else {
+      columns = []
+    }
+
+    return { name: view.name, pascalName, skipped, columns, tags: viewTags }
+  })
+
+  // ── Enums ─────────────────────────────────────────────────────
+  // Extract from all columns (tables + views) since Atlas surfaces enum info per-column
+  const enums: EnrichedEnum[] = extractEnums(tables, views)
+
+  // ── Functions ─────────────────────────────────────────────────
+  const rawFuncs = ctx.realm.schemas.flatMap((s) => s.funcs ?? [])
+  const functions: EnrichedFunction[] = rawFuncs.map((fn) => ({
+    name: fn.name,
+    pascalName: toPascalCase(fn.name),
+    args: (fn.args ?? []).map((a) => ({
+      name: a.name ?? '',
+      type: a.type?.T ?? a.type?.raw ?? 'unknown',
+      category: a.type?.category ?? 'unknown',
+    })),
+    returnType: fn.ret
+      ? {
+          type: fn.ret.T ?? fn.ret.raw ?? 'unknown',
+          category: fn.ret.category ?? 'unknown',
+        }
+      : undefined,
+    language: fn.lang,
+  }))
+
+  return { tables, views, enums, functions }
+}
+
+/**
+ * Get only non-skipped tables from an enriched schema.
+ */
+export function activeTables(schema: EnrichedSchema): EnrichedTable[] {
+  return schema.tables.filter((t) => !t.skipped)
+}
+
+/**
+ * Find tags with a specific namespace on a table or column.
+ */
+export function findTagsByNamespace(tags: TagEntry[], namespace: string): TagEntry[] {
+  return tags.filter((t) => t.namespace === namespace)
+}
+
+/**
+ * Get the first arg value from a tag (for positional args).
+ */
+export function getTagArg(tag: TagEntry, index: number = 0): unknown {
+  if (Array.isArray(tag.args)) return tag.args[index]
+  return undefined
+}
+
+/**
+ * Get a named arg value from a tag.
+ */
+export function getNamedArg(tag: TagEntry, key: string): unknown {
+  if (!Array.isArray(tag.args)) return (tag.args as Record<string, unknown>)[key]
+  return undefined
+}
+
+// ── Internals ────────────────────────────────────────────────────
+
+/**
+ * Resolve view columns from its SELECT definition by matching column names
+ * to source table columns. Handles "SELECT col1, col2 FROM tablename".
+ */
+function resolveViewColumns(
+  viewDef: string,
+  tables: EnrichedTable[],
+  _viewName: string,
+  _templateName: string,
+  _allFileTags: TemplateContext<any>['allFileTags'],
+): EnrichedColumn[] {
+  // Parse "SELECT col1, col2, ... FROM tablename"
+  const selectMatch = viewDef.match(/SELECT\s+([\s\S]+?)\s+FROM\s+(\w+)/i)
+  if (!selectMatch) return []
+
+  const colList = selectMatch[1]
+  const sourceTableName = selectMatch[2]
+  const sourceTable = tables.find((t) => t.name === sourceTableName)
+  if (!sourceTable) return []
+
+  // Handle SELECT *
+  if (colList.trim() === '*') {
+    return sourceTable.columns.map((col) => ({
+      ...col,
+      isPrimaryKey: false,
+      isSerial: false,
+      foreignKey: undefined,
+    }))
+  }
+
+  // Parse column names (strip whitespace, handle aliases)
+  const colNames = colList.split(',').map((c) => {
+    const trimmed = c.trim()
+    // Handle "col AS alias" — use the original column name for lookup
+    const asMatch = trimmed.match(/^(\w+)\s+AS\s+/i)
+    return asMatch ? asMatch[1] : trimmed
+  })
+
+  return colNames
+    .map((name) => sourceTable.columns.find((c) => c.name === name))
+    .filter((c): c is EnrichedColumn => c != null)
+    .map((col) => ({
+      ...col,
+      // Views are read-only — no PK/FK/serial
+      isPrimaryKey: false,
+      isSerial: false,
+      foreignKey: undefined,
+    }))
+}
+
+/** Enrich a single column using Atlas type metadata */
+function enrichColumn(
+  col: AtlasColumn,
+  parentName: string,
+  templateName: string,
+  allFileTags: TemplateContext<any>['allFileTags'],
+  pkColumns?: Set<string>,
+  fkMap?: Map<string, { table: string; column: string }>,
+): EnrichedColumn {
+  const colTags = findTagsForObject(allFileTags, `${parentName}.${col.name}`)
+  const pgType = getColumnType(col)
+  const nullable = isNullable(col)
+  const typeOverride = findTypeOverride(colTags, templateName)
+  const defaultValue = extractDefault(col.default)
+  const category = (col.type?.category ?? 'unknown') as TypeCategory
+  const isSerial = category === 'integer' && pgType.toLowerCase().includes('serial')
+
+  return {
+    name: col.name,
+    pascalName: toPascalCase(col.name),
+    camelName: toCamelCase(col.name),
+    pgType,
+    category,
+    isCustomType: col.type?.is_custom ?? false,
+    enumValues: col.type?.enum_values,
+    compositeFields: col.type?.composite_fields,
+    nullable,
+    isPrimaryKey: pkColumns?.has(col.name) ?? false,
+    isSerial,
+    defaultValue,
+    foreignKey: fkMap?.get(col.name),
+    typeOverride,
+    tags: colTags,
+    raw: col,
+  }
+}
+
+/** Extract enums from all columns (tables + views) with category 'enum' and enum_values */
+function extractEnums(tables: EnrichedTable[], views: EnrichedView[]): EnrichedEnum[] {
+  const found = new Map<string, string[]>()
+
+  const allColumns = [...tables.flatMap((t) => t.columns), ...views.flatMap((v) => v.columns)]
+
+  for (const col of allColumns) {
+    if (col.category === 'enum' && col.enumValues?.length && !found.has(col.pgType)) {
+      found.set(col.pgType, col.enumValues)
+    }
+  }
+
+  return [...found.entries()].map(([name, values]) => ({
+    name,
+    pascalName: toPascalCase(name),
+    values,
+  }))
+}
+
+function extractDefault(def: unknown): string | undefined {
+  if (!def || typeof def !== 'object') return undefined
+  const d = def as Record<string, unknown>
+  if ('X' in d) return String(d.X)
+  if ('V' in d) return String(d.V)
+  return undefined
+}
+
+function toCamelCase(name: string): string {
+  const pascal = toPascalCase(name)
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1)
+}

package/src/helpers/naming.ts

@@ -0,0 +1,19 @@
+/** Convert snake_case to PascalCase: "user_accounts" -> "UserAccounts" */
+export function toPascalCase(snake: string): string {
+  return snake
+    .split('_')
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('')
+}
+
+/** Convert snake_case to camelCase: "user_accounts" -> "userAccounts" */
+export function toCamelCase(snake: string): string {
+  const pascal = toPascalCase(snake)
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1)
+}
+
+/** Convert snake_case to SCREAMING_SNAKE: "user_status" -> "USER_STATUS" */
+export function toScreamingSnake(snake: string): string {
+  return snake.toUpperCase()
+}

package/src/helpers/tags.ts

@@ -0,0 +1,63 @@
+interface TagInfo {
+  namespace: string
+  tag: string | null
+  args: Record<string, unknown> | unknown[]
+}
+
+/** Find @codegen.rename for a specific object, optionally scoped to template */
+export function findRename(tags: TagInfo[], templateName: string): string | undefined {
+  // First check template-specific rename
+  const specific = tags.find(
+    (t) =>
+      t.namespace === 'codegen' &&
+      t.tag === 'rename' &&
+      Array.isArray(t.args) &&
+      t.args.length === 2 &&
+      t.args[1] === templateName,
+  )
+  if (specific && Array.isArray(specific.args)) return specific.args[0] as string
+
+  // Then check global rename (single arg)
+  const global = tags.find(
+    (t) => t.namespace === 'codegen' && t.tag === 'rename' && Array.isArray(t.args) && t.args.length === 1,
+  )
+  if (global && Array.isArray(global.args)) return global.args[0] as string
+
+  return undefined
+}
+
+/** Check if @codegen.skip applies to this template */
+export function isSkipped(tags: TagInfo[], templateName: string): boolean {
+  return tags.some(
+    (t) =>
+      t.namespace === 'codegen' &&
+      t.tag === 'skip' &&
+      // Global skip (no args or empty)
+      (!Array.isArray(t.args) ||
+        t.args.length === 0 ||
+        // Template-specific skip
+        (Array.isArray(t.args) && t.args[0] === templateName)),
+  )
+}
+
+/** Find @codegen.type override for a column, optionally scoped to template */
+export function findTypeOverride(tags: TagInfo[], templateName: string): string | undefined {
+  // First check template-specific type override
+  const specific = tags.find(
+    (t) =>
+      t.namespace === 'codegen' &&
+      t.tag === 'type' &&
+      Array.isArray(t.args) &&
+      t.args.length === 2 &&
+      t.args[1] === templateName,
+  )
+  if (specific && Array.isArray(specific.args)) return specific.args[0] as string
+
+  // Then check global type override (single arg)
+  const global = tags.find(
+    (t) => t.namespace === 'codegen' && t.tag === 'type' && Array.isArray(t.args) && t.args.length === 1,
+  )
+  if (global && Array.isArray(global.args)) return global.args[0] as string
+
+  return undefined
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+// Type mappers
+
+// Atlas helpers
+export { findTagsForObject, getColumnType, getTablesFromRealm, getViewsFromRealm, isNullable } from './helpers/atlas.ts'
+export type {
+  EnrichedColumn,
+  EnrichedEnum,
+  EnrichedFunction,
+  EnrichedSchema,
+  EnrichedTable,
+  EnrichedView,
+  Relation,
+  TagEntry,
+} from './helpers/enrich.ts'
+// Enrichment layer
+export { activeTables, enrichRealm, findTagsByNamespace, getNamedArg, getTagArg } from './helpers/enrich.ts'
+// Naming helpers
+export { toCamelCase, toPascalCase, toScreamingSnake } from './helpers/naming.ts'
+// Tag lookup helpers
+export { findRename, findTypeOverride, isSkipped } from './helpers/tags.ts'
+// Tag functions (re-exported for convenience)
+export { csharp, dedent, go, java, kotlin, python, rust, sql, ts } from './tags.ts'
+export type { TsTypeOptions } from './types.ts'
+export { pgToCsharp, pgToGo, pgToJava, pgToKotlin, pgToPython, pgToRust, pgToTs } from './types.ts'

package/src/java-records/index.ts

@@ -0,0 +1,179 @@
+import { defineTemplate } from '@sqldoc/ns-codegen'
+import { activeTables, enrichRealm } from '../helpers/enrich.ts'
+import { toCamelCase, toPascalCase, toScreamingSnake } from '../helpers/naming.ts'
+import { pgToJava } from '../types/pg-to-java.ts'
+
+export default defineTemplate({
+  name: 'Java Records',
+  description: 'Generate Java record classes from SQL schema',
+  language: 'java',
+
+  generate(ctx) {
+    const schema = enrichRealm(ctx)
+    const files: Array<{ path: string; content: string }> = []
+
+    // Enums
+    for (const e of schema.enums) {
+      const className = toPascalCase(e.name)
+      const members = e.values.map((v) => {
+        const constName = toScreamingSnake(v)
+        return `    ${constName}("${v}")`
+      })
+
+      const parts: string[] = []
+      parts.push(`public enum ${className} {`)
+      parts.push(`${members.join(',\n')};`)
+      parts.push('')
+      parts.push(`    private final String value;`)
+      parts.push('')
+      parts.push(`    ${className}(String value) {`)
+      parts.push(`        this.value = value;`)
+      parts.push(`    }`)
+      parts.push('')
+      parts.push(`    public String getValue() {`)
+      parts.push(`        return value;`)
+      parts.push(`    }`)
+      parts.push('}')
+      parts.push('')
+
+      files.push({
+        path: `${className}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    // Composite types (collected from columns)
+    const composites = new Map<string, Array<{ name: string; type: string }>>()
+    for (const table of schema.tables) {
+      for (const col of table.columns) {
+        if (col.category === 'composite' && col.compositeFields?.length && !composites.has(col.pgType)) {
+          composites.set(col.pgType, col.compositeFields)
+        }
+      }
+    }
+    for (const [name, fields] of composites) {
+      const className = toPascalCase(name)
+      const allImports = new Set<string>()
+
+      const recordFields: string[] = []
+      for (const f of fields) {
+        const mapped = pgToJava(f.type, false)
+        for (const imp of mapped.imports) allImports.add(imp)
+        recordFields.push(`    ${mapped.type} ${toCamelCase(f.name)}`)
+      }
+
+      const importLines: string[] = []
+      const sortedImports = [...allImports].sort()
+      for (const imp of sortedImports) {
+        importLines.push(`import ${imp};`)
+      }
+
+      const parts: string[] = []
+      if (importLines.length > 0) {
+        parts.push(importLines.join('\n'))
+        parts.push('')
+      }
+      parts.push(`public record ${className}(`)
+      parts.push(recordFields.join(',\n'))
+      parts.push(') {}')
+      parts.push('')
+
+      files.push({
+        path: `${className}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    for (const table of activeTables(schema)) {
+      const allImports = new Set<string>()
+
+      const fields: string[] = []
+      for (const col of table.columns) {
+        let javaType: string
+        if (col.typeOverride) {
+          javaType = col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else {
+          const mapped = pgToJava(col.pgType, col.nullable, col.category)
+          javaType = mapped.type
+          for (const imp of mapped.imports) allImports.add(imp)
+        }
+
+        fields.push(`    ${javaType} ${col.camelName}`)
+      }
+
+      const importLines: string[] = []
+      const sortedImports = [...allImports].sort()
+      for (const imp of sortedImports) {
+        importLines.push(`import ${imp};`)
+      }
+
+      const parts: string[] = []
+      if (importLines.length > 0) {
+        parts.push(importLines.join('\n'))
+        parts.push('')
+      }
+      parts.push(`public record ${table.pascalName}(`)
+      parts.push(fields.join(',\n'))
+      parts.push(') {}')
+      parts.push('')
+
+      files.push({
+        path: `${table.pascalName}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    // Views (read-only)
+    for (const view of schema.views.filter((v) => !v.skipped)) {
+      const allImports = new Set<string>()
+
+      const fields: string[] = []
+      for (const col of view.columns) {
+        let javaType: string
+        if (col.typeOverride) {
+          javaType = col.typeOverride
+        } else if (col.category === 'enum' && col.enumValues?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else if (col.category === 'composite' && col.compositeFields?.length) {
+          javaType = toPascalCase(col.pgType)
+        } else {
+          const mapped = pgToJava(col.pgType, col.nullable, col.category)
+          javaType = mapped.type
+          for (const imp of mapped.imports) allImports.add(imp)
+        }
+
+        fields.push(`    ${javaType} ${col.camelName}`)
+      }
+
+      const importLines: string[] = []
+      const sortedImports = [...allImports].sort()
+      for (const imp of sortedImports) {
+        importLines.push(`import ${imp};`)
+      }
+
+      const parts: string[] = []
+      if (importLines.length > 0) {
+        parts.push(importLines.join('\n'))
+        parts.push('')
+      }
+      parts.push(`/** Read-only (from view) */`)
+      parts.push(`public record ${view.pascalName}(`)
+      parts.push(fields.join(',\n'))
+      parts.push(') {}')
+      parts.push('')
+
+      files.push({
+        path: `${view.pascalName}.java`,
+        content: parts.join('\n'),
+      })
+    }
+
+    // Functions (skip trigger functions — Java doesn't have SQL function type patterns)
+
+    return { files }
+  },
+})

package/src/java-records/test/.gitignore

@@ -0,0 +1,6 @@
+# Generated by codegen — only Dockerfile and test scripts are tracked
+*
+!.gitignore
+!Dockerfile
+!test.*
+!Test.*

package/src/java-records/test/Dockerfile

@@ -0,0 +1,11 @@
+FROM eclipse-temurin:21-jdk-alpine
+WORKDIR /app
+RUN apk add --no-cache curl
+# Download PostgreSQL JDBC driver
+RUN mkdir -p /deps && \
+    curl -sL -o /deps/postgresql-42.7.4.jar https://repo1.maven.org/maven2/org/postgresql/postgresql/42.7.4/postgresql-42.7.4.jar
+COPY . .
+# Step 1: compile the generated records + test
+RUN javac -cp "/deps/*:." *.java Test.java
+# Step 2: run integration test against real DB
+CMD ["java", "-cp", "/deps/*:.", "Test"]