orcaq 1.0.33 → 1.1.2

package/.output/server/chunks/_/metadata.factory.mjs

@@ -1,5 +1,661 @@
 import { D as DatabaseClientType } from './db-connection.mjs';
+import { r as resolveMetadataTypeAlias } from './type-alias.constants.mjs';
 import { B as BaseDomainAdapter, c as createDomainAdapter } from './create-adapter.mjs';
+import { V as ViewSchemaEnum, F as FunctionSchemaEnum } from './schemaMeta.type.mjs';
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, key + "" , value);
+const EXCLUDED_SCHEMAS = [
+  "information_schema",
+  "mysql",
+  "performance_schema",
+  "sys"
+];
+const EXCLUDED_SCHEMA_PLACEHOLDERS = EXCLUDED_SCHEMAS.map(() => "?").join(", ");
+class MysqlMetadataAdapter extends BaseDomainAdapter {
+  constructor(adapter, dbType) {
+    super(adapter);
+    __publicField$3(this, "dbType");
+    this.dbType = dbType;
+  }
+  static async create(params, dbType = DatabaseClientType.MYSQL) {
+    const adapter = await MysqlMetadataAdapter.resolveAdapter(params, dbType);
+    return new MysqlMetadataAdapter(adapter, dbType);
+  }
+  async loadMetadataRows() {
+    const [schemas, tables, columns, primaryKeys, foreignKeys, routines] = await Promise.all([
+      this.adapter.rawQuery(
+        `
+            SELECT schema_name AS schema_name
+            FROM information_schema.schemata
+            WHERE schema_name NOT IN (${EXCLUDED_SCHEMA_PLACEHOLDERS})
+            ORDER BY schema_name
+          `,
+        EXCLUDED_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT
+              table_schema AS table_schema,
+              table_name AS table_name,
+              table_type AS table_type,
+              table_rows AS table_rows,
+              table_comment AS table_comment
+            FROM information_schema.tables
+            WHERE table_schema NOT IN (${EXCLUDED_SCHEMA_PLACEHOLDERS})
+            ORDER BY table_schema, table_name
+          `,
+        EXCLUDED_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT
+              table_schema AS table_schema,
+              table_name AS table_name,
+              column_name AS column_name,
+              ordinal_position AS ordinal_position,
+              column_type AS column_type,
+              data_type AS data_type,
+              is_nullable AS is_nullable,
+              column_default AS column_default
+            FROM information_schema.columns
+            WHERE table_schema NOT IN (${EXCLUDED_SCHEMA_PLACEHOLDERS})
+            ORDER BY table_schema, table_name, ordinal_position
+          `,
+        EXCLUDED_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT
+              table_schema AS table_schema,
+              table_name AS table_name,
+              column_name AS column_name
+            FROM information_schema.key_column_usage
+            WHERE constraint_name = 'PRIMARY'
+              AND table_schema NOT IN (${EXCLUDED_SCHEMA_PLACEHOLDERS})
+            ORDER BY table_schema, table_name, ordinal_position
+          `,
+        EXCLUDED_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT
+              table_schema AS table_schema,
+              table_name AS table_name,
+              column_name AS column_name,
+              referenced_table_schema AS referenced_table_schema,
+              referenced_table_name AS referenced_table_name,
+              referenced_column_name AS referenced_column_name
+            FROM information_schema.key_column_usage
+            WHERE referenced_table_name IS NOT NULL
+              AND table_schema NOT IN (${EXCLUDED_SCHEMA_PLACEHOLDERS})
+            ORDER BY table_schema, table_name, ordinal_position
+          `,
+        EXCLUDED_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT
+              routine_schema AS routine_schema,
+              routine_name AS routine_name,
+              routine_type AS routine_type
+            FROM information_schema.routines
+            WHERE routine_schema NOT IN (${EXCLUDED_SCHEMA_PLACEHOLDERS})
+            ORDER BY routine_schema, routine_name
+          `,
+        EXCLUDED_SCHEMAS
+      )
+    ]);
+    return {
+      schemas,
+      tables,
+      columns,
+      primaryKeys,
+      foreignKeys,
+      routines
+    };
+  }
+  async getSchemaMetaData() {
+    const { schemas, tables, columns, primaryKeys, foreignKeys, routines } = await this.loadMetadataRows();
+    return schemas.map(({ schema_name }) => {
+      const schemaTables = tables.filter(
+        (table) => table.table_schema === schema_name
+      );
+      const baseTables = schemaTables.filter(
+        (table) => table.table_type === "BASE TABLE"
+      );
+      const schemaViews = schemaTables.filter(
+        (table) => table.table_type === "VIEW"
+      );
+      const table_details = Object.fromEntries(
+        baseTables.map((table) => {
+          const tableColumns = columns.filter(
+            (column) => column.table_schema === schema_name && column.table_name === table.table_name
+          ).map((column) => ({
+            raw_type_name: column.column_type,
+            name: column.column_name,
+            ordinal_position: column.ordinal_position,
+            type: column.column_type,
+            short_type_name: resolveMetadataTypeAlias(
+              this.dbType,
+              column.column_type
+            ),
+            is_nullable: column.is_nullable === "YES",
+            default_value: column.column_default
+          }));
+          const tablePrimaryKeys = primaryKeys.filter(
+            (primaryKey) => primaryKey.table_schema === schema_name && primaryKey.table_name === table.table_name
+          ).map((primaryKey) => ({ column: primaryKey.column_name }));
+          const tableForeignKeys = foreignKeys.filter(
+            (foreignKey) => foreignKey.table_schema === schema_name && foreignKey.table_name === table.table_name
+          ).map((foreignKey) => ({
+            column: foreignKey.column_name,
+            referenced_column: foreignKey.referenced_column_name,
+            referenced_table: foreignKey.referenced_table_name,
+            referenced_table_schema: foreignKey.referenced_table_schema
+          }));
+          return [
+            table.table_name,
+            {
+              columns: tableColumns,
+              foreign_keys: tableForeignKeys,
+              primary_keys: tablePrimaryKeys,
+              table_id: `${schema_name}.${table.table_name}`
+            }
+          ];
+        })
+      );
+      const view_details = Object.fromEntries(
+        schemaViews.map((view) => {
+          const viewColumns = columns.filter(
+            (column) => column.table_schema === schema_name && column.table_name === view.table_name
+          ).map((column) => ({
+            raw_type_name: column.column_type,
+            name: column.column_name,
+            ordinal_position: column.ordinal_position,
+            type: column.column_type,
+            short_type_name: resolveMetadataTypeAlias(
+              this.dbType,
+              column.column_type
+            ),
+            is_nullable: column.is_nullable === "YES",
+            default_value: column.column_default
+          }));
+          return [
+            view.table_name,
+            {
+              columns: viewColumns,
+              view_id: `${schema_name}.${view.table_name}`,
+              type: ViewSchemaEnum.View
+            }
+          ];
+        })
+      );
+      const functions = routines.filter((routine) => routine.routine_schema === schema_name).map((routine) => ({
+        oId: `${schema_name}.${routine.routine_name}`,
+        name: routine.routine_name,
+        type: routine.routine_type === "PROCEDURE" ? FunctionSchemaEnum.Procedure : FunctionSchemaEnum.Function,
+        parameters: ""
+      }));
+      const views = schemaViews.map((view) => ({
+        name: view.table_name,
+        type: ViewSchemaEnum.View,
+        oid: `${schema_name}.${view.table_name}`
+      }));
+      return {
+        name: schema_name,
+        tables: baseTables.map((table) => table.table_name),
+        views,
+        functions,
+        table_details,
+        view_details
+      };
+    });
+  }
+  async getErdData() {
+    const [databaseInfo] = await this.adapter.rawQuery(
+      "SELECT DATABASE() AS database_name, VERSION() AS version"
+    );
+    const schemaMeta = await this.getSchemaMetaData();
+    const tables = schemaMeta.flatMap(
+      (schema) => (schema.tables || []).map((tableName) => {
+        var _a;
+        const detail = (_a = schema.table_details) == null ? void 0 : _a[tableName];
+        return {
+          id: (detail == null ? void 0 : detail.table_id) || `${schema.name}.${tableName}`,
+          schema: schema.name,
+          table: tableName,
+          rows: 0,
+          type: "TABLE",
+          comment: null,
+          columns: (detail == null ? void 0 : detail.columns.map((column) => ({
+            name: column.name,
+            ordinal_position: column.ordinal_position,
+            short_type_name: column.short_type_name,
+            type: column.type,
+            character_maximum_length: null,
+            precision: null,
+            nullable: column.is_nullable,
+            default: column.default_value,
+            collation: null,
+            comment: null
+          }))) || [],
+          foreign_keys: (detail == null ? void 0 : detail.foreign_keys.map((foreignKey) => ({
+            foreign_key_name: `${foreignKey.column}_fk`,
+            column: foreignKey.column,
+            reference_schema: foreignKey.referenced_table_schema,
+            reference_table: foreignKey.referenced_table,
+            reference_column: foreignKey.referenced_column,
+            fk_def: `${foreignKey.column} -> ${foreignKey.referenced_table}.${foreignKey.referenced_column}`
+          }))) || [],
+          primary_keys: (detail == null ? void 0 : detail.primary_keys.map((primaryKey) => ({
+            column: primaryKey.column,
+            pk_def: `PRIMARY KEY (${primaryKey.column})`
+          }))) || [],
+          indexes: []
+        };
+      })
+    );
+    const views = schemaMeta.flatMap(
+      (schema) => (schema.views || []).map((view) => ({
+        schema: schema.name,
+        view_name: view.name,
+        view_definition: ""
+      }))
+    );
+    return {
+      tables,
+      views,
+      databaseName: (databaseInfo == null ? void 0 : databaseInfo.database_name) || "",
+      version: (databaseInfo == null ? void 0 : databaseInfo.version) || "",
+      config: []
+    };
+  }
+  async getReverseSchemas() {
+    const { tables, primaryKeys, foreignKeys } = await this.loadMetadataRows();
+    return tables.filter((table) => table.table_type === "BASE TABLE").map((table) => ({
+      schema: table.table_schema,
+      table: table.table_name,
+      rows: table.table_rows || 0,
+      type: table.table_type,
+      primary_keys: primaryKeys.filter(
+        (primaryKey) => primaryKey.table_schema === table.table_schema && primaryKey.table_name === table.table_name
+      ).map((primaryKey) => ({ column: primaryKey.column_name })),
+      used_by: foreignKeys.filter(
+        (foreignKey) => foreignKey.referenced_table_schema === table.table_schema && foreignKey.referenced_table_name === table.table_name
+      ).map((foreignKey) => ({
+        referencing_schema: foreignKey.table_schema,
+        referencing_table: foreignKey.table_name,
+        foreign_key_name: `${foreignKey.table_name}.${foreignKey.column_name}`,
+        fk_column: foreignKey.column_name,
+        referenced_column: foreignKey.referenced_column_name
+      }))
+    }));
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, key + "" , value);
+const SYSTEM_SCHEMAS = [
+  "ANONYMOUS",
+  "APPQOSSYS",
+  "AUDSYS",
+  "CTXSYS",
+  "DBSNMP",
+  "DVSYS",
+  "GSMADMIN_INTERNAL",
+  "LBACSYS",
+  "MDSYS",
+  "OJVMSYS",
+  "ORDSYS",
+  "OUTLN",
+  "SYS",
+  "SYSBACKUP",
+  "SYSDG",
+  "SYSKM",
+  "SYSTEM",
+  "WMSYS",
+  "XDB"
+];
+function buildBindPlaceholders(count, start = 1) {
+  return Array.from({ length: count }, (_, index) => `:${index + start}`).join(
+    ", "
+  );
+}
+function formatOracleType(column) {
+  if (column.data_type === "NUMBER" && column.data_precision !== null) {
+    return column.data_scale !== null ? `NUMBER(${column.data_precision}, ${column.data_scale})` : `NUMBER(${column.data_precision})`;
+  }
+  if (["VARCHAR2", "NVARCHAR2", "CHAR", "NCHAR", "RAW"].includes(
+    column.data_type
+  ) && column.data_length !== null) {
+    return `${column.data_type}(${column.data_length})`;
+  }
+  return column.data_type;
+}
+class OracleMetadataAdapter extends BaseDomainAdapter {
+  constructor() {
+    super(...arguments);
+    __publicField$2(this, "dbType", DatabaseClientType.ORACLE);
+  }
+  static async create(params) {
+    const adapter = await OracleMetadataAdapter.resolveAdapter(
+      params,
+      DatabaseClientType.ORACLE
+    );
+    return new OracleMetadataAdapter(adapter);
+  }
+  async loadMetadataRows() {
+    const schemaPlaceholders = buildBindPlaceholders(SYSTEM_SCHEMAS.length);
+    const [
+      schemas,
+      tables,
+      views,
+      columns,
+      primaryKeys,
+      foreignKeys,
+      routines
+    ] = await Promise.all([
+      this.adapter.rawQuery(
+        `
+            SELECT username AS schema_name
+            FROM all_users
+            WHERE username NOT IN (${schemaPlaceholders})
+            ORDER BY username
+          `,
+        SYSTEM_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT t.owner, t.table_name, t.num_rows, c.comments
+            FROM all_tables t
+            LEFT JOIN all_tab_comments c
+              ON c.owner = t.owner
+              AND c.table_name = t.table_name
+            WHERE t.owner NOT IN (${schemaPlaceholders})
+            ORDER BY t.owner, t.table_name
+          `,
+        SYSTEM_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT owner, view_name
+            FROM all_views
+            WHERE owner NOT IN (${schemaPlaceholders})
+            ORDER BY owner, view_name
+          `,
+        SYSTEM_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT
+              owner,
+              table_name,
+              column_name,
+              column_id,
+              data_type,
+              data_length,
+              data_precision,
+              data_scale,
+              nullable,
+              TRIM(data_default) AS data_default
+            FROM all_tab_columns
+            WHERE owner NOT IN (${schemaPlaceholders})
+            ORDER BY owner, table_name, column_id
+          `,
+        SYSTEM_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT acc.owner, acc.table_name, acc.column_name
+            FROM all_constraints ac
+            JOIN all_cons_columns acc
+              ON acc.owner = ac.owner
+              AND acc.constraint_name = ac.constraint_name
+            WHERE ac.constraint_type = 'P'
+              AND ac.owner NOT IN (${schemaPlaceholders})
+            ORDER BY acc.owner, acc.table_name, acc.position
+          `,
+        SYSTEM_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT
+              acc.owner,
+              acc.table_name,
+              acc.column_name,
+              r_acc.owner AS referenced_owner,
+              r_acc.table_name AS referenced_table_name,
+              r_acc.column_name AS referenced_column_name
+            FROM all_constraints ac
+            JOIN all_cons_columns acc
+              ON acc.owner = ac.owner
+              AND acc.constraint_name = ac.constraint_name
+            JOIN all_constraints r_ac
+              ON r_ac.owner = ac.r_owner
+              AND r_ac.constraint_name = ac.r_constraint_name
+            JOIN all_cons_columns r_acc
+              ON r_acc.owner = r_ac.owner
+              AND r_acc.constraint_name = r_ac.constraint_name
+              AND r_acc.position = acc.position
+            WHERE ac.constraint_type = 'R'
+              AND ac.owner NOT IN (${schemaPlaceholders})
+            ORDER BY acc.owner, acc.table_name, acc.position
+          `,
+        SYSTEM_SCHEMAS
+      ),
+      this.adapter.rawQuery(
+        `
+            SELECT owner, object_name, object_type
+            FROM all_objects
+            WHERE object_type IN ('FUNCTION', 'PROCEDURE')
+              AND owner NOT IN (${schemaPlaceholders})
+            ORDER BY owner, object_name
+          `,
+        SYSTEM_SCHEMAS
+      )
+    ]);
+    return {
+      schemas,
+      tables,
+      views,
+      columns,
+      primaryKeys,
+      foreignKeys,
+      routines
+    };
+  }
+  async getSchemaMetaData() {
+    const {
+      schemas,
+      tables,
+      views,
+      columns,
+      primaryKeys,
+      foreignKeys,
+      routines
+    } = await this.loadMetadataRows();
+    return schemas.map(({ schema_name }) => {
+      const schemaTables = tables.filter((table) => table.owner === schema_name);
+      const schemaViews = views.filter((view) => view.owner === schema_name);
+      const table_details = Object.fromEntries(
+        schemaTables.map((table) => {
+          const tableColumns = columns.filter(
+            (column) => column.owner === schema_name && column.table_name === table.table_name
+          ).map((column) => ({
+            raw_type_name: formatOracleType(column),
+            name: column.column_name,
+            ordinal_position: column.column_id,
+            type: formatOracleType(column),
+            short_type_name: resolveMetadataTypeAlias(
+              this.dbType,
+              formatOracleType(column)
+            ),
+            is_nullable: column.nullable === "Y",
+            default_value: column.data_default
+          }));
+          const tablePrimaryKeys = primaryKeys.filter(
+            (primaryKey) => primaryKey.owner === schema_name && primaryKey.table_name === table.table_name
+          ).map((primaryKey) => ({ column: primaryKey.column_name }));
+          const tableForeignKeys = foreignKeys.filter(
+            (foreignKey) => foreignKey.owner === schema_name && foreignKey.table_name === table.table_name
+          ).map((foreignKey) => ({
+            column: foreignKey.column_name,
+            referenced_column: foreignKey.referenced_column_name,
+            referenced_table: foreignKey.referenced_table_name,
+            referenced_table_schema: foreignKey.referenced_owner
+          }));
+          return [
+            table.table_name,
+            {
+              columns: tableColumns,
+              foreign_keys: tableForeignKeys,
+              primary_keys: tablePrimaryKeys,
+              table_id: `${schema_name}.${table.table_name}`
+            }
+          ];
+        })
+      );
+      const view_details = Object.fromEntries(
+        schemaViews.map((view) => {
+          const viewColumns = columns.filter(
+            (column) => column.owner === schema_name && column.table_name === view.view_name
+          ).map((column) => ({
+            raw_type_name: formatOracleType(column),
+            name: column.column_name,
+            ordinal_position: column.column_id,
+            type: formatOracleType(column),
+            short_type_name: resolveMetadataTypeAlias(
+              this.dbType,
+              formatOracleType(column)
+            ),
+            is_nullable: column.nullable === "Y",
+            default_value: column.data_default
+          }));
+          return [
+            view.view_name,
+            {
+              columns: viewColumns,
+              view_id: `${schema_name}.${view.view_name}`,
+              type: ViewSchemaEnum.View
+            }
+          ];
+        })
+      );
+      const functions = routines.filter((routine) => routine.owner === schema_name).map((routine) => ({
+        oId: `${schema_name}.${routine.object_name}`,
+        name: routine.object_name,
+        type: routine.object_type === "PROCEDURE" ? FunctionSchemaEnum.Procedure : FunctionSchemaEnum.Function,
+        parameters: ""
+      }));
+      const schemaViewsList = schemaViews.map((view) => ({
+        name: view.view_name,
+        type: ViewSchemaEnum.View,
+        oid: `${schema_name}.${view.view_name}`
+      }));
+      return {
+        name: schema_name,
+        tables: schemaTables.map((table) => table.table_name),
+        views: schemaViewsList,
+        functions,
+        table_details,
+        view_details
+      };
+    });
+  }
+  async getErdData() {
+    const [databaseInfo] = await this.adapter.rawQuery(
+      `
+        SELECT
+          SYS_CONTEXT('USERENV', 'DB_NAME') AS database_name,
+          (
+            SELECT version
+            FROM product_component_version
+            WHERE product LIKE 'Oracle Database%'
+              AND ROWNUM = 1
+          ) AS version
+        FROM dual
+      `
+    );
+    const schemaMeta = await this.getSchemaMetaData();
+    const tables = schemaMeta.flatMap(
+      (schema) => (schema.tables || []).map((tableName) => {
+        var _a;
+        const detail = (_a = schema.table_details) == null ? void 0 : _a[tableName];
+        return {
+          id: (detail == null ? void 0 : detail.table_id) || `${schema.name}.${tableName}`,
+          schema: schema.name,
+          table: tableName,
+          rows: 0,
+          type: "TABLE",
+          comment: null,
+          columns: (detail == null ? void 0 : detail.columns.map((column) => ({
+            name: column.name,
+            ordinal_position: column.ordinal_position,
+            short_type_name: column.short_type_name,
+            type: column.type,
+            character_maximum_length: null,
+            precision: null,
+            nullable: column.is_nullable,
+            default: column.default_value,
+            collation: null,
+            comment: null
+          }))) || [],
+          foreign_keys: (detail == null ? void 0 : detail.foreign_keys.map((foreignKey) => ({
+            foreign_key_name: `${foreignKey.column}_fk`,
+            column: foreignKey.column,
+            reference_schema: foreignKey.referenced_table_schema,
+            reference_table: foreignKey.referenced_table,
+            reference_column: foreignKey.referenced_column,
+            fk_def: `${foreignKey.column} -> ${foreignKey.referenced_table}.${foreignKey.referenced_column}`
+          }))) || [],
+          primary_keys: (detail == null ? void 0 : detail.primary_keys.map((primaryKey) => ({
+            column: primaryKey.column,
+            pk_def: `PRIMARY KEY (${primaryKey.column})`
+          }))) || [],
+          indexes: []
+        };
+      })
+    );
+    const views = schemaMeta.flatMap(
+      (schema) => (schema.views || []).map((view) => ({
+        schema: schema.name,
+        view_name: view.name,
+        view_definition: ""
+      }))
+    );
+    return {
+      tables,
+      views,
+      databaseName: (databaseInfo == null ? void 0 : databaseInfo.database_name) || "",
+      version: (databaseInfo == null ? void 0 : databaseInfo.version) || "",
+      config: []
+    };
+  }
+  async getReverseSchemas() {
+    const { tables, primaryKeys, foreignKeys } = await this.loadMetadataRows();
+    return tables.map((table) => ({
+      schema: table.owner,
+      table: table.table_name,
+      rows: table.num_rows || 0,
+      type: "TABLE",
+      primary_keys: primaryKeys.filter(
+        (primaryKey) => primaryKey.owner === table.owner && primaryKey.table_name === table.table_name
+      ).map((primaryKey) => ({ column: primaryKey.column_name })),
+      used_by: foreignKeys.filter(
+        (foreignKey) => foreignKey.referenced_owner === table.owner && foreignKey.referenced_table_name === table.table_name
+      ).map((foreignKey) => ({
+        referencing_schema: foreignKey.owner,
+        referencing_table: foreignKey.table_name,
+        foreign_key_name: `${foreignKey.table_name}.${foreignKey.column_name}`,
+        fk_column: foreignKey.column_name,
+        referenced_column: foreignKey.referenced_column_name
+      }))
+    }));
+  }
+}
 
 const getSchemaMetaDataQuery = `
       SELECT
@@ -47,20 +703,9 @@ const getSchemaMetaDataQuery = `
                     'name', a.attname,
                     'ordinal_position', a.attnum,
                     'type', format_type(a.atttypid, a.atttypmod),
+                    'raw_type_name', format_type(a.atttypid, a.atttypmod),
                     'is_nullable', NOT a.attnotnull,
-                    'short_type_name',
-                      CASE
-                        WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character varying%'
-                          THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character varying', 'varchar')
-                        WHEN format_type(a.atttypid, a.atttypmod) = 'integer' THEN 'int4'
-                        WHEN format_type(a.atttypid, a.atttypmod) = 'bigint' THEN 'int8'
-                        WHEN format_type(a.atttypid, a.atttypmod) = 'boolean' THEN 'bool'
-                        WHEN format_type(a.atttypid, a.atttypmod) LIKE 'numeric%'
-                          THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'numeric', 'decimal')
-                        WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp without time zone' THEN 'timestamp'
-                        WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp with time zone' THEN 'timestamptz'
-                        ELSE format_type(a.atttypid, a.atttypmod)
-                      END
+                    'short_type_name', format_type(a.atttypid, a.atttypmod)
                   )
                   ORDER BY a.attnum
                 )
@@ -110,32 +755,10 @@ const getSchemaMetaDataQuery = `
                     'name', a.attname,
                     'ordinal_position', a.attnum,
                     'type', format_type(a.atttypid, a.atttypmod),
+                    'raw_type_name', format_type(a.atttypid, a.atttypmod),
                     'is_nullable', NOT a.attnotnull,
                     'default_value', pg_get_expr(d.adbin, d.adrelid),
-                    'short_type_name',
-                    CASE
-                      WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character varying%' 
-                          THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character varying', 'varchar')
-                      WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character%' 
-                          THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character', 'char')
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'double precision' THEN 'float8'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'integer' THEN 'int4'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'smallint' THEN 'int2'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'bigint' THEN 'int8'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'real' THEN 'float4'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'serial' THEN 'serial4'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'smallserial' THEN 'serial2'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'bigserial' THEN 'serial8'
-                      WHEN format_type(a.atttypid, a.atttypmod) LIKE 'bit varying%' 
-                          THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'bit varying', 'varbit')
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'boolean' THEN 'bool'
-                      WHEN format_type(a.atttypid, a.atttypmod) LIKE 'numeric%' 
-                      THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'numeric', 'decimal')
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp with time zone' THEN 'timestamptz'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp without time zone' THEN 'timestamp'
-                      WHEN format_type(a.atttypid, a.atttypmod) = 'time with time zone' THEN 'timetz'
-                      ELSE format_type(a.atttypid, a.atttypmod)
-                    END -- short type with length, user-friendly 
+                    'short_type_name', format_type(a.atttypid, a.atttypmod)
                   )
                 )
                 FROM pg_attribute a
@@ -536,13 +1159,38 @@ const getReverseSchemasQuery = `
       tbls;
 `;
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
+const normalizeSchemaColumns = (columns) => (columns || []).map((column) => {
+  const rawType = column.raw_type_name || column.type;
+  return {
+    ...column,
+    raw_type_name: rawType,
+    short_type_name: resolveMetadataTypeAlias(
+      DatabaseClientType.POSTGRES,
+      rawType
+    )
+  };
+});
+const normalizeDetails = (details) => {
+  if (!details) {
+    return details != null ? details : null;
+  }
+  return Object.fromEntries(
+    Object.entries(details).map(([name, detail]) => [
+      name,
+      {
+        ...detail,
+        columns: normalizeSchemaColumns(detail.columns)
+      }
+    ])
+  );
+};
 class PostgresMetadataAdapter extends BaseDomainAdapter {
   constructor() {
     super(...arguments);
-    __publicField(this, "dbType", DatabaseClientType.POSTGRES);
+    __publicField$1(this, "dbType", DatabaseClientType.POSTGRES);
   }
   static async create(params) {
     const adapter = await PostgresMetadataAdapter.resolveAdapter(
@@ -552,7 +1200,15 @@ class PostgresMetadataAdapter extends BaseDomainAdapter {
     return new PostgresMetadataAdapter(adapter);
   }
   async getSchemaMetaData() {
-    return await this.adapter.rawQuery(getSchemaMetaDataQuery, []);
+    const metadata = await this.adapter.rawQuery(
+      getSchemaMetaDataQuery,
+      []
+    );
+    return metadata.map((schema) => ({
+      ...schema,
+      table_details: normalizeDetails(schema.table_details),
+      view_details: normalizeDetails(schema.view_details)
+    }));
   }
   async getErdData() {
     var _a;
@@ -572,9 +1228,502 @@ class PostgresMetadataAdapter extends BaseDomainAdapter {
   }
 }
 
+function escapeSqliteIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function quoteSqliteString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function isD1Connection(connection) {
+  return typeof connection === "string" && connection.startsWith("d1://");
+}
+function normalizeSqliteIdentifier(value) {
+  return value.trim().replace(/^["'`\[]|["'`\]]$/g, "");
+}
+function splitTopLevelSql(input) {
+  const segments = [];
+  let current = "";
+  let depth = 0;
+  let quote = null;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    const next = input[index + 1];
+    current += char;
+    if (quote) {
+      if (char === quote) {
+        if (quote === "'" && next === "'") {
+          current += next;
+          index += 1;
+          continue;
+        }
+        quote = null;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (char === "," && depth === 0) {
+      segments.push(current.slice(0, -1).trim());
+      current = "";
+    }
+  }
+  if (current.trim()) {
+    segments.push(current.trim());
+  }
+  return segments;
+}
+function extractCreateSqlBody(sql) {
+  const firstParen = sql.indexOf("(");
+  if (firstParen === -1) return "";
+  let depth = 0;
+  let quote = null;
+  for (let index = firstParen; index < sql.length; index += 1) {
+    const char = sql[index];
+    const next = sql[index + 1];
+    if (quote) {
+      if (char === quote) {
+        if (quote === "'" && next === "'") {
+          index += 1;
+          continue;
+        }
+        quote = null;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return sql.slice(firstParen + 1, index);
+    }
+  }
+  return "";
+}
+function parseDefaultValue(definition) {
+  var _a, _b;
+  const match = definition.match(
+    /\bdefault\b\s+(.+?)(?=\s+(?:constraint|primary|not|null|unique|check|references|collate|generated)\b|$)/i
+  );
+  return (_b = (_a = match == null ? void 0 : match[1]) == null ? void 0 : _a.trim()) != null ? _b : null;
+}
+function parseInlineReference(definition) {
+  var _a, _b, _c;
+  const match = definition.match(
+    /\breferences\b\s+([^\s(]+)\s*(?:\(([^)]+)\))?/i
+  );
+  if (!match) return null;
+  return {
+    referencedTable: normalizeSqliteIdentifier((_a = match[1]) != null ? _a : ""),
+    referencedColumn: normalizeSqliteIdentifier(
+      (_c = (_b = match[2]) == null ? void 0 : _b.split(",")[0]) != null ? _c : "id"
+    )
+  };
+}
+function parseColumnDefinition(definition, schema, ordinalPosition) {
+  var _a, _b;
+  const trimmed = definition.trim();
+  if (/^(constraint|primary\s+key|foreign\s+key|unique|check)\b/i.test(trimmed)) {
+    return null;
+  }
+  const nameMatch = trimmed.match(
+    /^("[^"]+"|'[^']+'|`[^`]+`|\[[^\]]+\]|[^\s]+)/
+  );
+  if (!nameMatch) return null;
+  const columnName = normalizeSqliteIdentifier((_a = nameMatch[1]) != null ? _a : "");
+  const remainder = trimmed.slice(nameMatch[0].length).trim();
+  const typeMatch = remainder.match(
+    /^(.*?)(?=\s+(?:constraint|primary|not|null|default|references|unique|check|collate|generated)\b|$)/i
+  );
+  const rawTypeName = ((_b = typeMatch == null ? void 0 : typeMatch[1]) == null ? void 0 : _b.trim()) || "TEXT";
+  const defaultValue = parseDefaultValue(remainder);
+  const reference = parseInlineReference(remainder);
+  return {
+    column: {
+      raw_type_name: rawTypeName,
+      name: columnName,
+      ordinal_position: ordinalPosition,
+      type: rawTypeName,
+      short_type_name: resolveMetadataTypeAlias(
+        DatabaseClientType.SQLITE3,
+        rawTypeName
+      ),
+      is_nullable: !/\bnot\s+null\b/i.test(remainder),
+      default_value: defaultValue
+    },
+    primaryKey: /\bprimary\s+key\b/i.test(remainder) ? { column: columnName } : null,
+    foreignKey: reference ? {
+      column: columnName,
+      referenced_column: reference.referencedColumn,
+      referenced_table: reference.referencedTable,
+      referenced_table_schema: schema
+    } : null
+  };
+}
+function parseTableConstraint(definition, schema) {
+  var _a, _b;
+  const normalized = definition.replace(/^constraint\s+[^\s]+\s+/i, "").trim();
+  const primaryKeyMatch = normalized.match(/^primary\s+key\s*\(([^)]+)\)/i);
+  if (primaryKeyMatch) {
+    return {
+      primaryKeys: primaryKeyMatch[1].split(",").map((column) => ({ column: normalizeSqliteIdentifier(column) })),
+      foreignKeys: []
+    };
+  }
+  const foreignKeyMatch = normalized.match(
+    /^foreign\s+key\s*\(([^)]+)\)\s+references\s+([^\s(]+)\s*(?:\(([^)]+)\))?/i
+  );
+  if (!foreignKeyMatch) {
+    return { primaryKeys: [], foreignKeys: [] };
+  }
+  const localColumns = foreignKeyMatch[1].split(",").map(normalizeSqliteIdentifier);
+  const referencedTable = normalizeSqliteIdentifier((_a = foreignKeyMatch[2]) != null ? _a : "");
+  const referencedColumns = ((_b = foreignKeyMatch[3]) != null ? _b : "").split(",").map(normalizeSqliteIdentifier);
+  return {
+    primaryKeys: [],
+    foreignKeys: localColumns.map((column, index) => ({
+      column,
+      referenced_column: referencedColumns[index] || referencedColumns[0] || "id",
+      referenced_table: referencedTable,
+      referenced_table_schema: schema
+    }))
+  };
+}
+function buildTableDetailFromCreateSql(schema, tableName, sql) {
+  const body = extractCreateSqlBody(sql || "");
+  const segments = splitTopLevelSql(body);
+  const columns = [];
+  const primaryKeys = [];
+  const foreignKeys = [];
+  segments.forEach((segment) => {
+    const columnDefinition = parseColumnDefinition(
+      segment,
+      schema,
+      columns.length + 1
+    );
+    if (columnDefinition) {
+      columns.push(columnDefinition.column);
+      if (columnDefinition.primaryKey && !primaryKeys.some((k) => {
+        var _a;
+        return k.column === ((_a = columnDefinition.primaryKey) == null ? void 0 : _a.column);
+      })) {
+        primaryKeys.push(columnDefinition.primaryKey);
+      }
+      if (columnDefinition.foreignKey) {
+        foreignKeys.push(columnDefinition.foreignKey);
+      }
+      return;
+    }
+    const constraint = parseTableConstraint(segment, schema);
+    constraint.primaryKeys.forEach((pk) => {
+      if (!primaryKeys.some((k) => k.column === pk.column)) {
+        primaryKeys.push(pk);
+      }
+    });
+    foreignKeys.push(...constraint.foreignKeys);
+  });
+  return {
+    columns,
+    foreign_keys: foreignKeys,
+    primary_keys: primaryKeys,
+    table_id: `${schema}.${tableName}`
+  };
+}
+function parseViewColumnsFromCreateSql(sql, schema, viewName) {
+  const explicitColumnsMatch = sql == null ? void 0 : sql.match(
+    /create\s+view\s+(?:if\s+not\s+exists\s+)?(?:[^\s(]+\s*)\(([^)]+)\)/i
+  );
+  const columns = explicitColumnsMatch ? explicitColumnsMatch[1].split(",").map(normalizeSqliteIdentifier).filter(Boolean).map((name, index) => ({
+    raw_type_name: "TEXT",
+    name,
+    ordinal_position: index + 1,
+    type: "TEXT",
+    short_type_name: resolveMetadataTypeAlias(
+      DatabaseClientType.SQLITE3,
+      "TEXT"
+    ),
+    is_nullable: true,
+    default_value: null
+  })) : [];
+  return {
+    columns,
+    view_id: `${schema}.${viewName}`,
+    type: ViewSchemaEnum.View
+  };
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+class SqliteMetadataAdapter extends BaseDomainAdapter {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "dbType", DatabaseClientType.SQLITE3);
+  }
+  static async create(params) {
+    const adapter = await SqliteMetadataAdapter.resolveAdapter(
+      params,
+      DatabaseClientType.SQLITE3
+    );
+    return new SqliteMetadataAdapter(adapter);
+  }
+  async getDatabases() {
+    try {
+      return await this.adapter.rawQuery(
+        "PRAGMA database_list"
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error != null ? error : "");
+      if (isD1Connection(this.adapter.connection) && /SQLITE_AUTH/i.test(message)) {
+        return [
+          {
+            seq: 0,
+            name: "main",
+            file: ""
+          }
+        ];
+      }
+      throw error;
+    }
+  }
+  async getSchemaObjects(schema) {
+    return this.adapter.rawQuery(
+      `
+        SELECT name, type, sql
+        FROM ${escapeSqliteIdentifier(schema)}.sqlite_master
+        WHERE type IN ('table', 'view')
+          AND name NOT LIKE 'sqlite_%'
+        ORDER BY type, name
+      `
+    );
+  }
+  async getTableInfo(schema, tableName) {
+    return this.adapter.rawQuery(
+      `PRAGMA ${escapeSqliteIdentifier(schema)}.table_info(${quoteSqliteString(tableName)})`
+    );
+  }
+  async getForeignKeys(schema, tableName) {
+    return this.adapter.rawQuery(
+      `PRAGMA ${escapeSqliteIdentifier(schema)}.foreign_key_list(${quoteSqliteString(tableName)})`
+    );
+  }
+  async getSchemaMetaData() {
+    const databases = await this.getDatabases();
+    const schemaMeta = [];
+    for (const database of databases.filter((db) => db.name !== "temp")) {
+      const objects = await this.getSchemaObjects(database.name);
+      const tables = objects.filter((object) => object.type === "table");
+      const views = objects.filter((object) => object.type === "view");
+      const table_details = Object.fromEntries(
+        await Promise.all(
+          tables.map(async (table) => {
+            if (isD1Connection(this.adapter.connection)) {
+              return [
+                table.name,
+                buildTableDetailFromCreateSql(
+                  database.name,
+                  table.name,
+                  table.sql
+                )
+              ];
+            }
+            const [columns, foreignKeys] = await Promise.all([
+              this.getTableInfo(database.name, table.name),
+              this.getForeignKeys(database.name, table.name)
+            ]);
+            return [
+              table.name,
+              {
+                columns: columns.map((column) => ({
+                  raw_type_name: column.type,
+                  name: column.name,
+                  ordinal_position: column.cid + 1,
+                  type: column.type,
+                  short_type_name: resolveMetadataTypeAlias(
+                    this.dbType,
+                    column.type
+                  ),
+                  is_nullable: column.notnull === 0,
+                  default_value: column.dflt_value
+                })),
+                foreign_keys: foreignKeys.map((foreignKey) => ({
+                  column: foreignKey.from,
+                  referenced_column: foreignKey.to,
+                  referenced_table: foreignKey.table,
+                  referenced_table_schema: database.name
+                })),
+                primary_keys: columns.filter((column) => column.pk > 0).sort((left, right) => left.pk - right.pk).map((column) => ({ column: column.name })),
+                table_id: `${database.name}.${table.name}`
+              }
+            ];
+          })
+        )
+      );
+      const view_details = Object.fromEntries(
+        await Promise.all(
+          views.map(async (view) => {
+            if (isD1Connection(this.adapter.connection)) {
+              return [
+                view.name,
+                parseViewColumnsFromCreateSql(
+                  view.sql,
+                  database.name,
+                  view.name
+                )
+              ];
+            }
+            const columns = await this.getTableInfo(database.name, view.name);
+            return [
+              view.name,
+              {
+                columns: columns.map((column) => ({
+                  raw_type_name: column.type,
+                  name: column.name,
+                  ordinal_position: column.cid + 1,
+                  type: column.type,
+                  short_type_name: resolveMetadataTypeAlias(
+                    this.dbType,
+                    column.type
+                  ),
+                  is_nullable: column.notnull === 0,
+                  default_value: column.dflt_value
+                })),
+                view_id: `${database.name}.${view.name}`,
+                type: ViewSchemaEnum.View
+              }
+            ];
+          })
+        )
+      );
+      schemaMeta.push({
+        name: database.name,
+        tables: tables.map((table) => table.name),
+        views: views.map((view) => ({
+          name: view.name,
+          type: ViewSchemaEnum.View,
+          oid: `${database.name}.${view.name}`
+        })),
+        functions: [],
+        table_details,
+        view_details
+      });
+    }
+    return schemaMeta;
+  }
+  async getErdData() {
+    const [versionRow] = await this.adapter.rawQuery(
+      "SELECT sqlite_version() AS version"
+    );
+    const databases = await this.getDatabases();
+    const schemaMeta = await this.getSchemaMetaData();
+    const tables = schemaMeta.flatMap(
+      (schema) => (schema.tables || []).map((tableName) => {
+        var _a;
+        const detail = (_a = schema.table_details) == null ? void 0 : _a[tableName];
+        return {
+          id: (detail == null ? void 0 : detail.table_id) || `${schema.name}.${tableName}`,
+          schema: schema.name,
+          table: tableName,
+          rows: 0,
+          type: "TABLE",
+          comment: null,
+          columns: (detail == null ? void 0 : detail.columns.map((column) => ({
+            name: column.name,
+            ordinal_position: column.ordinal_position,
+            short_type_name: column.short_type_name,
+            type: column.type,
+            character_maximum_length: null,
+            precision: null,
+            nullable: column.is_nullable,
+            default: column.default_value,
+            collation: null,
+            comment: null
+          }))) || [],
+          foreign_keys: (detail == null ? void 0 : detail.foreign_keys.map((foreignKey) => ({
+            foreign_key_name: `${foreignKey.column}_fk`,
+            column: foreignKey.column,
+            reference_schema: foreignKey.referenced_table_schema,
+            reference_table: foreignKey.referenced_table,
+            reference_column: foreignKey.referenced_column,
+            fk_def: `${foreignKey.column} -> ${foreignKey.referenced_table}.${foreignKey.referenced_column}`
+          }))) || [],
+          primary_keys: (detail == null ? void 0 : detail.primary_keys.map((primaryKey) => ({
+            column: primaryKey.column,
+            pk_def: `PRIMARY KEY (${primaryKey.column})`
+          }))) || [],
+          indexes: []
+        };
+      })
+    );
+    const views = schemaMeta.flatMap(
+      (schema) => (schema.views || []).map((view) => ({
+        schema: schema.name,
+        view_name: view.name,
+        view_definition: ""
+      }))
+    );
+    const mainDatabase = databases.find((database) => database.name === "main");
+    return {
+      tables,
+      views,
+      databaseName: (mainDatabase == null ? void 0 : mainDatabase.file) || (mainDatabase == null ? void 0 : mainDatabase.name) || "",
+      version: (versionRow == null ? void 0 : versionRow.version) || "",
+      config: []
+    };
+  }
+  async getReverseSchemas() {
+    const schemaMeta = await this.getSchemaMetaData();
+    return schemaMeta.flatMap(
+      (schema) => (schema.tables || []).map((tableName) => {
+        var _a;
+        const detail = (_a = schema.table_details) == null ? void 0 : _a[tableName];
+        return {
+          schema: schema.name,
+          table: tableName,
+          rows: 0,
+          type: "TABLE",
+          primary_keys: (detail == null ? void 0 : detail.primary_keys) || [],
+          used_by: schemaMeta.flatMap(
+            (otherSchema) => Object.entries(otherSchema.table_details || {}).flatMap(
+              ([referencingTable, referencingDetail]) => (referencingDetail.foreign_keys || []).filter(
+                (foreignKey) => foreignKey.referenced_table_schema === schema.name && foreignKey.referenced_table === tableName
+              ).map((foreignKey) => ({
+                referencing_schema: otherSchema.name,
+                referencing_table: referencingTable,
+                foreign_key_name: `${referencingTable}.${foreignKey.column}`,
+                fk_column: foreignKey.column,
+                referenced_column: foreignKey.referenced_column
+              }))
+            )
+          )
+        };
+      })
+    );
+  }
+}
+
 async function createMetadataAdapter(dbType, params) {
   return createDomainAdapter(dbType, params, "metadata", {
-    postgres: PostgresMetadataAdapter.create
+    postgres: PostgresMetadataAdapter.create,
+    mysql: (params2) => MysqlMetadataAdapter.create(params2, DatabaseClientType.MYSQL),
+    mariadb: (params2) => MysqlMetadataAdapter.create(params2, DatabaseClientType.MARIADB),
+    oracledb: OracleMetadataAdapter.create,
+    sqlite3: SqliteMetadataAdapter.create
   });
 }