@kmlckj/licos-platform-sdk 0.6.3 → 0.6.4

package/src/database.js

@@ -1,255 +1,688 @@
-import { ApiError } from './shared.js';
-import { authHeaders, runtimeConfig } from './runtime.js';
-
-function databaseConfig() {
-  return runtimeConfig();
-}
-
-function databaseUrl(config, route) {
-  return `${config.baseUrl}/api/v1/studio/runtime/database/projects/${encodeURIComponent(config.projectId)}${route}`;
-}
-
-function compactObject(value) {
-  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== null));
-}
-
-function normalizeSelect(select) {
-  if (select === undefined || select === null) return undefined;
-  if (typeof select === 'string') {
-    return select.split(',').map((item) => item.trim()).filter(Boolean);
-  }
-  return Array.from(select).map((item) => String(item));
-}
-
-async function decodeResponse(response) {
-  const text = await response.text();
-  const payload = text ? JSON.parse(text) : null;
-  if (!response.ok) {
-    throw new ApiError(text || `platform database API returned ${response.status}`, {
-      status: response.status,
-      details: payload,
-    });
-  }
-  if (!payload || typeof payload !== 'object') return payload;
-  if ((payload.code !== undefined && payload.code !== 0) || payload.success === false) {
-    throw new ApiError(payload.message || 'platform database API failed', {
-      status: response.status,
-      code: typeof payload.code === 'number' ? payload.code : undefined,
-      details: payload,
-    });
-  }
-  return payload.data;
-}
-
-async function requestJson(route, body) {
-  const config = databaseConfig();
-  const payload = { environment: config.environment, ...compactObject(body) };
-  const response = await fetch(databaseUrl(config, route), {
-    method: 'POST',
-    headers: authHeaders(config),
-    body: JSON.stringify(payload),
-  });
-  return decodeResponse(response);
-}
-
-export async function query(table, options = {}) {
-  return requestJson('/query', {
-    table,
-    select: normalizeSelect(options.select),
-    filters: options.filters?.length ? options.filters : undefined,
-    orderBy: options.orderBy?.length ? options.orderBy : undefined,
-    range: options.range,
-    limit: options.limit,
-    offset: options.offset,
-    count: options.count,
-    head: options.head,
-  });
-}
-
-export async function single(table, options = {}) {
-  return requestJson('/single', {
-    table,
-    select: normalizeSelect(options.select),
-    filters: options.filters?.length ? options.filters : undefined,
-    orderBy: options.orderBy?.length ? options.orderBy : undefined,
-    mode: options.maybe ? 'maybe_single' : 'single',
-  });
-}
-
-export async function maybeSingle(table, options = {}) {
-  return single(table, { ...options, maybe: true });
-}
-
-export async function aggregate(table, aggregateName, options = {}) {
-  return requestJson('/aggregate', {
-    table,
-    filters: options.filters?.length ? options.filters : undefined,
-    aggregate: aggregateName,
-    field: options.field,
-    groupBy: options.groupBy?.length ? options.groupBy : undefined,
-  });
-}
-
-export async function insert(table, options = {}) {
-  return requestJson('/insert', {
-    table,
-    row: options.row,
-    rows: options.rows,
-    returning: options.returning ?? true,
-  });
-}
-
-export async function updateRows(table, options = {}) {
-  return requestJson('/update', {
-    table,
-    values: options.values,
-    filters: options.filters?.length ? options.filters : undefined,
-    updates: options.updates?.length ? options.updates : undefined,
-    returning: options.returning ?? true,
-  });
-}
-
-export async function deleteRows(table, options = {}) {
-  return requestJson('/delete', {
-    table,
-    filters: options.filters?.length ? options.filters : undefined,
-    deletes: options.deletes?.length ? options.deletes : undefined,
-    returning: options.returning ?? true,
-  });
-}
-
-export async function upsert(table, options = {}) {
-  return requestJson('/upsert', {
-    table,
-    row: options.row,
-    rows: options.rows,
-    conflictKeys: options.conflictKeys?.length ? options.conflictKeys : undefined,
-    returning: options.returning ?? true,
-  });
-}
-
-export async function transaction(operations) {
-  const config = databaseConfig();
-  const normalized = operations.map((operation) => ({
-    type: operation.type,
-    request: {
-      ...operation.request,
-      environment: config.environment,
-    },
-  }));
-  return requestJson('/transaction', { operations: normalized });
-}
-
-export async function rpc(functionName, args = {}) {
-  return requestJson(`/rpc/${encodeURIComponent(functionName)}`, { args });
-}
-
-export function table(name) {
-  return new TableQuery(name);
-}
-
-class TableQuery {
-  constructor(name) {
-    this.name = name;
-    this._select = undefined;
-    this._filters = [];
-    this._orderBy = [];
-    this._range = undefined;
-    this._limit = undefined;
-    this._offset = undefined;
-    this._count = undefined;
-    this._head = undefined;
-  }
-
-  select(...fields) {
-    this._select = fields.length === 1 && fields[0].includes(',') ? normalizeSelect(fields[0]) : fields;
-    return this;
-  }
-
-  filter(field, op, value) {
-    this._filters.push({ field, op, value });
-    return this;
-  }
-
-  eq(field, value) { return this.filter(field, 'eq', value); }
-  neq(field, value) { return this.filter(field, 'neq', value); }
-  gt(field, value) { return this.filter(field, 'gt', value); }
-  gte(field, value) { return this.filter(field, 'gte', value); }
-  lt(field, value) { return this.filter(field, 'lt', value); }
-  lte(field, value) { return this.filter(field, 'lte', value); }
-  in(field, value) { return this.filter(field, 'in', value); }
-  notIn(field, value) { return this.filter(field, 'not_in', value); }
-  isNull(field) { return this.filter(field, 'is_null'); }
-  isNotNull(field) { return this.filter(field, 'is_not_null'); }
-  like(field, value) { return this.filter(field, 'like', value); }
-  ilike(field, value) { return this.filter(field, 'ilike', value); }
-
-  order(field, options = {}) {
-    this._orderBy.push({ field, direction: options.desc ? 'desc' : 'asc' });
-    return this;
-  }
-
-  range(from, to) {
-    this._range = { from, to };
-    return this;
-  }
-
-  limit(value) {
-    this._limit = value;
-    return this;
-  }
-
-  offset(value) {
-    this._offset = value;
-    return this;
-  }
-
-  withCount(options = {}) {
-    this._count = true;
-    this._head = Boolean(options.head);
-    return this;
-  }
-
-  execute() {
-    return query(this.name, {
-      select: this._select,
-      filters: this._filters,
-      orderBy: this._orderBy,
-      range: this._range,
-      limit: this._limit,
-      offset: this._offset,
-      count: this._count,
-      head: this._head,
-    });
-  }
-
-  single() {
-    return single(this.name, {
-      select: this._select,
-      filters: this._filters,
-      orderBy: this._orderBy,
-    });
-  }
-
-  maybeSingle() {
-    return maybeSingle(this.name, {
-      select: this._select,
-      filters: this._filters,
-      orderBy: this._orderBy,
-    });
-  }
-}
-
-export const database = {
-  query,
-  single,
-  maybeSingle,
-  aggregate,
-  insert,
-  updateRows,
-  deleteRows,
-  upsert,
-  transaction,
-  rpc,
-  table,
-};
+import { ApiError } from './shared.js';
+import { authHeaders, runtimeConfig } from './runtime.js';
+
+function databaseConfig() {
+  return runtimeConfig();
+}
+
+function databaseUrl(config, route) {
+  return `${config.baseUrl}/api/v1/studio/runtime/database/projects/${encodeURIComponent(config.projectId)}${route}`;
+}
+
+function controlDatabaseUrl(config, route) {
+  return `${config.baseUrl}/api/v1/studio/control/database/projects/${encodeURIComponent(config.projectId)}${route}`;
+}
+
+function compactObject(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== null));
+}
+
+function normalizeSelect(select) {
+  if (select === undefined || select === null) return undefined;
+  if (typeof select === 'string') {
+    return select.split(',').map((item) => item.trim()).filter(Boolean);
+  }
+  return Array.from(select).map((item) => String(item));
+}
+
+async function decodeResponse(response) {
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    throw new ApiError(text || `platform database API returned ${response.status}`, {
+      status: response.status,
+      details: payload,
+    });
+  }
+  if (!payload || typeof payload !== 'object') return payload;
+  if ((payload.code !== undefined && payload.code !== 0) || payload.success === false) {
+    throw new ApiError(payload.message || 'platform database API failed', {
+      status: response.status,
+      code: typeof payload.code === 'number' ? payload.code : undefined,
+      details: payload,
+    });
+  }
+  return payload.data;
+}
+
+async function requestJson(route, body) {
+  const config = databaseConfig();
+  const payload = { environment: config.environment, ...compactObject(body) };
+  const response = await fetch(databaseUrl(config, route), {
+    method: 'POST',
+    headers: authHeaders(config),
+    body: JSON.stringify(payload),
+  });
+  return decodeResponse(response);
+}
+
+async function requestControlJson(route, query = {}) {
+  const config = databaseConfig();
+  const url = new URL(controlDatabaseUrl(config, route));
+  for (const [key, value] of Object.entries({ environment: config.environment, ...query })) {
+    if (value !== undefined && value !== null) url.searchParams.set(key, String(value));
+  }
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: authHeaders(config),
+  });
+  return decodeResponse(response);
+}
+
+export async function query(table, options = {}) {
+  return requestJson('/query', {
+    table,
+    select: normalizeSelect(options.select),
+    filters: options.filters?.length ? options.filters : undefined,
+    orderBy: options.orderBy?.length ? options.orderBy : undefined,
+    range: options.range,
+    limit: options.limit,
+    offset: options.offset,
+    count: options.count,
+    head: options.head,
+  });
+}
+
+export async function single(table, options = {}) {
+  return requestJson('/single', {
+    table,
+    select: normalizeSelect(options.select),
+    filters: options.filters?.length ? options.filters : undefined,
+    orderBy: options.orderBy?.length ? options.orderBy : undefined,
+    mode: options.maybe ? 'maybe_single' : 'single',
+  });
+}
+
+export async function maybeSingle(table, options = {}) {
+  return single(table, { ...options, maybe: true });
+}
+
+export async function aggregate(table, aggregateName, options = {}) {
+  return requestJson('/aggregate', {
+    table,
+    filters: options.filters?.length ? options.filters : undefined,
+    aggregate: aggregateName,
+    field: options.field,
+    groupBy: options.groupBy?.length ? options.groupBy : undefined,
+  });
+}
+
+export async function insert(table, options = {}) {
+  return requestJson('/insert', {
+    table,
+    row: options.row,
+    rows: options.rows,
+    returning: options.returning ?? true,
+  });
+}
+
+export async function updateRows(table, options = {}) {
+  return requestJson('/update', {
+    table,
+    values: options.values,
+    filters: options.filters?.length ? options.filters : undefined,
+    updates: options.updates?.length ? options.updates : undefined,
+    returning: options.returning ?? true,
+  });
+}
+
+export async function deleteRows(table, options = {}) {
+  return requestJson('/delete', {
+    table,
+    filters: options.filters?.length ? options.filters : undefined,
+    deletes: options.deletes?.length ? options.deletes : undefined,
+    returning: options.returning ?? true,
+  });
+}
+
+export async function upsert(table, options = {}) {
+  return requestJson('/upsert', {
+    table,
+    row: options.row,
+    rows: options.rows,
+    conflictKeys: options.conflictKeys?.length ? options.conflictKeys : undefined,
+    returning: options.returning ?? true,
+  });
+}
+
+export async function transaction(operations) {
+  const config = databaseConfig();
+  const normalized = operations.map((operation) => ({
+    type: operation.type,
+    request: {
+      ...operation.request,
+      environment: config.environment,
+    },
+  }));
+  return requestJson('/transaction', { operations: normalized });
+}
+
+export async function rpc(functionName, args = {}) {
+  return requestJson(`/rpc/${encodeURIComponent(functionName)}`, { args });
+}
+
+export async function getSchema() {
+  return requestControlJson('/schema');
+}
+
+export function defaultOrm(language) {
+  return normalizeLanguage(language) === 'typescript' ? 'drizzle' : 'sqlalchemy';
+}
+
+export function generateOrm(schemaPayload, options = {}) {
+  const language = normalizeLanguage(options.language);
+  const orm = normalizeOrm(language, options.orm);
+  if (language === 'typescript' && orm === 'drizzle') return generateDrizzle(schemaPayload);
+  if (language === 'python' && orm === 'sqlalchemy') return generateSqlAlchemy(schemaPayload);
+  throw new Error(`unsupported ORM export target: ${options.language}/${options.orm ?? 'default'}`);
+}
+
+export async function exportOrm(options = {}) {
+  const schemaPayload = await getSchema();
+  return generateOrm(schemaPayload, options);
+}
+
+export function table(name) {
+  return new TableQuery(name);
+}
+
+class TableQuery {
+  constructor(name) {
+    this.name = name;
+    this._select = undefined;
+    this._filters = [];
+    this._orderBy = [];
+    this._range = undefined;
+    this._limit = undefined;
+    this._offset = undefined;
+    this._count = undefined;
+    this._head = undefined;
+  }
+
+  select(...fields) {
+    this._select = fields.length === 1 && fields[0].includes(',') ? normalizeSelect(fields[0]) : fields;
+    return this;
+  }
+
+  filter(field, op, value) {
+    this._filters.push({ field, op, value });
+    return this;
+  }
+
+  eq(field, value) { return this.filter(field, 'eq', value); }
+  neq(field, value) { return this.filter(field, 'neq', value); }
+  gt(field, value) { return this.filter(field, 'gt', value); }
+  gte(field, value) { return this.filter(field, 'gte', value); }
+  lt(field, value) { return this.filter(field, 'lt', value); }
+  lte(field, value) { return this.filter(field, 'lte', value); }
+  in(field, value) { return this.filter(field, 'in', value); }
+  notIn(field, value) { return this.filter(field, 'not_in', value); }
+  isNull(field) { return this.filter(field, 'is_null'); }
+  isNotNull(field) { return this.filter(field, 'is_not_null'); }
+  like(field, value) { return this.filter(field, 'like', value); }
+  ilike(field, value) { return this.filter(field, 'ilike', value); }
+
+  order(field, options = {}) {
+    this._orderBy.push({ field, direction: options.desc ? 'desc' : 'asc' });
+    return this;
+  }
+
+  range(from, to) {
+    this._range = { from, to };
+    return this;
+  }
+
+  limit(value) {
+    this._limit = value;
+    return this;
+  }
+
+  offset(value) {
+    this._offset = value;
+    return this;
+  }
+
+  withCount(options = {}) {
+    this._count = true;
+    this._head = Boolean(options.head);
+    return this;
+  }
+
+  execute() {
+    return query(this.name, {
+      select: this._select,
+      filters: this._filters,
+      orderBy: this._orderBy,
+      range: this._range,
+      limit: this._limit,
+      offset: this._offset,
+      count: this._count,
+      head: this._head,
+    });
+  }
+
+  single() {
+    return single(this.name, {
+      select: this._select,
+      filters: this._filters,
+      orderBy: this._orderBy,
+    });
+  }
+
+  maybeSingle() {
+    return maybeSingle(this.name, {
+      select: this._select,
+      filters: this._filters,
+      orderBy: this._orderBy,
+    });
+  }
+}
+
+function normalizeLanguage(value) {
+  const aliases = {
+    ts: 'typescript',
+    node: 'typescript',
+    nodejs: 'typescript',
+    js: 'typescript',
+    javascript: 'typescript',
+    py: 'python',
+  };
+  const normalized = aliases[String(value || '').trim().toLowerCase()] || String(value || '').trim().toLowerCase();
+  if (!['typescript', 'python'].includes(normalized)) {
+    throw new Error('language must be typescript or python');
+  }
+  return normalized;
+}
+
+function normalizeOrm(language, value) {
+  const normalized = String(value || defaultOrm(language)).trim().toLowerCase();
+  if (language === 'typescript' && normalized !== 'drizzle') {
+    throw new Error('typescript ORM export only supports drizzle');
+  }
+  if (language === 'python' && normalized !== 'sqlalchemy') {
+    throw new Error('python ORM export only supports sqlalchemy');
+  }
+  return normalized;
+}
+
+function tables(schemaPayload) {
+  return Array.isArray(schemaPayload?.tables) ? schemaPayload.tables : [];
+}
+
+function columns(tableValue) {
+  return Array.isArray(tableValue?.columns) ? tableValue.columns : [];
+}
+
+function words(value) {
+  const matches = String(value || 'value').match(/[A-Za-z0-9]+/g);
+  return matches?.length ? matches : ['value'];
+}
+
+function lowerCamel(value) {
+  const parts = words(value);
+  let ident = parts[0].toLowerCase() + parts.slice(1).map((word) => word[0].toUpperCase() + word.slice(1).toLowerCase()).join('');
+  if (/^[0-9]/.test(ident)) ident = `_${ident}`;
+  if (TS_RESERVED.has(ident)) ident = `${ident}_`;
+  return ident;
+}
+
+function pascal(value) {
+  let ident = words(value).map((word) => word[0].toUpperCase() + word.slice(1).toLowerCase()).join('');
+  if (/^[0-9]/.test(ident)) ident = `_${ident}`;
+  return ident;
+}
+
+function snake(value) {
+  let ident = words(value).map((word) => word.toLowerCase()).join('_');
+  if (/^[0-9]/.test(ident)) ident = `_${ident}`;
+  if (PY_RESERVED.has(ident)) ident = `${ident}_`;
+  return ident;
+}
+
+function unique(base, used, fallbackPrefix) {
+  let candidate = base;
+  if (used.has(candidate) && fallbackPrefix) {
+    candidate = `${fallbackPrefix}${base[0].toUpperCase()}${base.slice(1)}`;
+  }
+  const original = candidate;
+  let index = 2;
+  while (used.has(candidate)) {
+    candidate = `${original}${index}`;
+    index += 1;
+  }
+  used.add(candidate);
+  return candidate;
+}
+
+function quote(value) {
+  return JSON.stringify(String(value));
+}
+
+function typeName(column) {
+  return String(column?.type || '').replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+function hasDefault(column) {
+  return column?.defaultValue !== undefined && column.defaultValue !== null && String(column.defaultValue).trim() !== '';
+}
+
+function generateDrizzle(schemaPayload) {
+  const schemaTables = tables(schemaPayload);
+  if (!schemaTables.length) {
+    return '// Generated by licos-platform database export-orm.\n// No tables found in schema.\n';
+  }
+
+  const pgImports = new Set();
+  let needsSql = false;
+  const usedTableNames = new Set();
+  const usedTypeNames = new Set();
+  const schemaNames = [...new Set(schemaTables.map((item) => String(item.schema || 'public')).filter((name) => name !== 'public'))].sort();
+  const schemaIdentifiers = Object.fromEntries(schemaNames.map((name) => [name, lowerCamel(`${name}_schema`)]));
+  if (schemaNames.length) pgImports.add('pgSchema');
+
+  const tableBlocks = [];
+  const typeBlocks = [];
+  for (const tableValue of schemaTables) {
+    const schemaName = String(tableValue.schema || 'public');
+    const tableName = String(tableValue.name || 'table');
+    const variable = unique(lowerCamel(tableName), usedTableNames, schemaName !== 'public' ? lowerCamel(schemaName) : undefined);
+    const typeAlias = unique(pascal(tableName), usedTypeNames, schemaName !== 'public' ? pascal(schemaName) : undefined);
+    const factory = schemaName === 'public' ? 'pgTable' : `${schemaIdentifiers[schemaName]}.table`;
+    if (schemaName === 'public') pgImports.add('pgTable');
+
+    const usedProps = new Set();
+    const columnLines = columns(tableValue).map((column) => {
+      const prop = unique(lowerCamel(column.name || 'column'), usedProps);
+      const { expression, imports, usesSql } = drizzleColumn(column);
+      imports.forEach((item) => pgImports.add(item));
+      needsSql = needsSql || usesSql;
+      return `  ${prop}: ${expression},`;
+    });
+    if (!columnLines.length) columnLines.push('  // No columns found.');
+    tableBlocks.push(`export const ${variable} = ${factory}(${quote(tableName)}, {\n${columnLines.join('\n')}\n});`);
+    typeBlocks.push(`export type ${typeAlias} = typeof ${variable}.$inferSelect;`);
+    typeBlocks.push(`export type New${typeAlias} = typeof ${variable}.$inferInsert;`);
+  }
+
+  const lines = ['// Generated by licos-platform database export-orm.', ''];
+  if (needsSql) lines.push("import { sql } from 'drizzle-orm';");
+  lines.push(`import { ${[...pgImports].sort().join(', ')} } from 'drizzle-orm/pg-core';`);
+  lines.push('');
+  for (const schemaName of schemaNames) {
+    lines.push(`const ${schemaIdentifiers[schemaName]} = pgSchema(${quote(schemaName)});`);
+  }
+  if (schemaNames.length) lines.push('');
+  lines.push(...tableBlocks, '', ...typeBlocks);
+  return `${lines.join('\n').trimEnd()}\n`;
+}
+
+function drizzleColumn(column) {
+  const dataType = typeName(column);
+  const imports = new Set();
+  let builder = 'text';
+  const args = [quote(column.name || 'column')];
+  if (dataType === 'uuid') builder = 'uuid';
+  else if (['integer', 'int', 'int4', 'serial'].includes(dataType)) builder = 'integer';
+  else if (['bigint', 'int8', 'bigserial'].includes(dataType)) {
+    builder = 'bigint';
+    args.push("{ mode: 'number' }");
+  } else if (['smallint', 'int2', 'smallserial'].includes(dataType)) builder = 'smallint';
+  else if (['boolean', 'bool'].includes(dataType)) builder = 'boolean';
+  else if (['character varying', 'varchar', 'character', 'char'].includes(dataType)) builder = 'varchar';
+  else if (['timestamp with time zone', 'timestamptz'].includes(dataType)) {
+    builder = 'timestamp';
+    args.push('{ withTimezone: true }');
+  } else if (['timestamp without time zone', 'timestamp'].includes(dataType)) builder = 'timestamp';
+  else if (dataType === 'date') builder = 'date';
+  else if (dataType.startsWith('time')) builder = 'time';
+  else if (['numeric', 'decimal'].includes(dataType)) builder = 'numeric';
+  else if (['double precision', 'float8'].includes(dataType)) builder = 'doublePrecision';
+  else if (['real', 'float4'].includes(dataType)) builder = 'real';
+  else if (dataType === 'json') builder = 'json';
+  else if (dataType === 'jsonb') builder = 'jsonb';
+
+  imports.add(builder);
+  let expression = `${builder}(${args.join(', ')})`;
+  if (column.primaryKey) expression += '.primaryKey()';
+  else if (column.nullable === false) expression += '.notNull()';
+  let usesSql = false;
+  if (hasDefault(column)) {
+    const defaultSql = String(column.defaultValue).replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+    expression += `.default(sql\`${defaultSql}\`)`;
+    usesSql = true;
+  }
+  return { expression, imports, usesSql };
+}
+
+function generateSqlAlchemy(schemaPayload) {
+  const schemaTables = tables(schemaPayload);
+  if (!schemaTables.length) {
+    return '# Generated by licos-platform database export-orm.\n# No tables found in schema.\n';
+  }
+
+  const sqlalchemyImports = new Set();
+  const typingImports = new Set();
+  const datetimeImports = new Set();
+  let needsDecimal = false;
+  let needsAny = false;
+  const usedClassNames = new Set();
+  const classBlocks = [];
+
+  for (const tableValue of schemaTables) {
+    const schemaName = String(tableValue.schema || 'public');
+    const tableName = String(tableValue.name || 'table');
+    const className = unique(pascal(tableName), usedClassNames, schemaName !== 'public' ? pascal(schemaName) : undefined);
+    const usedAttrs = new Set();
+    const body = [`    __tablename__ = ${quote(tableName)}`];
+    if (schemaName !== 'public') body.push(`    __table_args__ = {"schema": ${quote(schemaName)}}`);
+    for (const column of columns(tableValue)) {
+      const attr = unique(snake(column.name || 'column'), usedAttrs);
+      const result = sqlalchemyColumn(column, attr);
+      result.imports.forEach((item) => sqlalchemyImports.add(item));
+      result.typingImports.forEach((item) => typingImports.add(item));
+      result.datetimeImports.forEach((item) => datetimeImports.add(item));
+      needsDecimal = needsDecimal || result.needsDecimal;
+      needsAny = needsAny || result.needsAny;
+      body.push(result.line);
+    }
+    if (body.length === (schemaName === 'public' ? 1 : 2)) body.push('    pass');
+    classBlocks.push(`class ${className}(Base):\n${body.join('\n')}`);
+  }
+
+  const lines = ['# Generated by licos-platform database export-orm.', 'from __future__ import annotations', ''];
+  if (datetimeImports.size) lines.push(`from datetime import ${[...datetimeImports].sort().join(', ')}`);
+  if (needsDecimal) lines.push('from decimal import Decimal');
+  if (typingImports.size || needsAny) {
+    lines.push(`from typing import ${[...[...typingImports], ...(needsAny ? ['Any'] : [])].sort().join(', ')}`);
+  }
+  if (datetimeImports.size || needsDecimal || typingImports.size || needsAny) lines.push('');
+  lines.push(`from sqlalchemy import ${[...sqlalchemyImports].sort().join(', ')}`);
+  lines.push('from sqlalchemy.orm import Mapped, mapped_column');
+  lines.push('');
+  lines.push('from .base import Base');
+  lines.push('');
+  lines.push(...classBlocks);
+  return `${lines.join('\n\n').trimEnd()}\n`;
+}
+
+function sqlalchemyColumn(column, attr) {
+  const dataType = typeName(column);
+  const imports = new Set();
+  const typingImports = new Set();
+  const datetimeImports = new Set();
+  let needsDecimal = false;
+  let needsAny = false;
+  let sqlType = 'Text';
+  let pyType = 'str';
+
+  if (dataType === 'uuid') {
+    sqlType = 'String(36)';
+    imports.add('String');
+  } else if (['integer', 'int', 'int4', 'serial', 'smallint', 'int2', 'smallserial'].includes(dataType)) {
+    sqlType = 'Integer';
+    pyType = 'int';
+    imports.add('Integer');
+  } else if (['bigint', 'int8', 'bigserial'].includes(dataType)) {
+    sqlType = 'BigInteger';
+    pyType = 'int';
+    imports.add('BigInteger');
+  } else if (['boolean', 'bool'].includes(dataType)) {
+    sqlType = 'Boolean';
+    pyType = 'bool';
+    imports.add('Boolean');
+  } else if (['character varying', 'varchar', 'character', 'char'].includes(dataType)) {
+    sqlType = 'String';
+    imports.add('String');
+  } else if (['timestamp with time zone', 'timestamptz'].includes(dataType)) {
+    sqlType = 'DateTime(timezone=True)';
+    pyType = 'datetime';
+    imports.add('DateTime');
+    datetimeImports.add('datetime');
+  } else if (['timestamp without time zone', 'timestamp'].includes(dataType)) {
+    sqlType = 'DateTime';
+    pyType = 'datetime';
+    imports.add('DateTime');
+    datetimeImports.add('datetime');
+  } else if (dataType === 'date') {
+    sqlType = 'Date';
+    pyType = 'date';
+    imports.add('Date');
+    datetimeImports.add('date');
+  } else if (dataType.startsWith('time')) {
+    sqlType = 'Time';
+    pyType = 'time';
+    imports.add('Time');
+    datetimeImports.add('time');
+  } else if (['numeric', 'decimal'].includes(dataType)) {
+    sqlType = 'Numeric';
+    pyType = 'Decimal';
+    imports.add('Numeric');
+    needsDecimal = true;
+  } else if (['double precision', 'float8', 'real', 'float4'].includes(dataType)) {
+    sqlType = 'Float';
+    pyType = 'float';
+    imports.add('Float');
+  } else if (['json', 'jsonb'].includes(dataType)) {
+    sqlType = 'JSON';
+    pyType = 'dict[str, Any]';
+    imports.add('JSON');
+    needsAny = true;
+  } else {
+    imports.add('Text');
+  }
+
+  if (column.nullable === true && !column.primaryKey) {
+    pyType = `Optional[${pyType}]`;
+    typingImports.add('Optional');
+  }
+
+  const args = [];
+  if (attr !== column.name) args.push(quote(column.name || attr));
+  args.push(sqlType);
+  if (column.primaryKey) args.push('primary_key=True');
+  if (column.nullable !== undefined && column.nullable !== null) args.push(`nullable=${Boolean(column.nullable) ? 'True' : 'False'}`);
+  if (hasDefault(column)) {
+    imports.add('text');
+    args.push(`server_default=text(${quote(column.defaultValue)})`);
+  }
+  return {
+    line: `    ${attr}: Mapped[${pyType}] = mapped_column(${args.join(', ')})`,
+    imports,
+    typingImports,
+    datetimeImports,
+    needsDecimal,
+    needsAny,
+  };
+}
+
+const TS_RESERVED = new Set([
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'export',
+  'extends',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'import',
+  'in',
+  'instanceof',
+  'new',
+  'return',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield',
+]);
+
+const PY_RESERVED = new Set([
+  'False',
+  'None',
+  'True',
+  'and',
+  'as',
+  'assert',
+  'async',
+  'await',
+  'break',
+  'class',
+  'continue',
+  'def',
+  'del',
+  'elif',
+  'else',
+  'except',
+  'finally',
+  'for',
+  'from',
+  'global',
+  'if',
+  'import',
+  'in',
+  'is',
+  'lambda',
+  'nonlocal',
+  'not',
+  'or',
+  'pass',
+  'raise',
+  'return',
+  'try',
+  'while',
+  'with',
+  'yield',
+]);
+
+export const database = {
+  query,
+  single,
+  maybeSingle,
+  aggregate,
+  insert,
+  updateRows,
+  deleteRows,
+  upsert,
+  transaction,
+  rpc,
+  getSchema,
+  defaultOrm,
+  generateOrm,
+  exportOrm,
+  table,
+};