simplemdg-dev-cli 2.0.4 → 2.4.4

package/src/core/db/db-cache.ts

@@ -0,0 +1,215 @@
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import fs from "fs-extra";
+import { decryptSecret, encryptSecret } from "./db-crypto";
+import type {
+  TDatabaseConnectionProfile,
+  TDatabaseType,
+  TPublicDatabaseConnection,
+  TResolvedDatabaseConnection,
+} from "./db-types";
+
+const CACHE_DIRECTORY = path.join(os.homedir(), ".simplemdg");
+const CONNECTIONS_FILE_PATH = path.join(CACHE_DIRECTORY, "db-connections.json");
+
+type TConnectionsCacheFile = {
+  connections: TDatabaseConnectionProfile[];
+};
+
+/**
+ * Draft used when creating or updating a connection. The password is provided
+ * in plain text and encrypted before it ever touches disk.
+ */
+export type TConnectionDraft = {
+  id?: string;
+  name: string;
+  type: TDatabaseType;
+  region?: string;
+  org?: string;
+  space?: string;
+  app?: string;
+  serviceName?: string;
+  servicePlan?: string;
+  host: string;
+  port: number;
+  database?: string;
+  schema?: string;
+  username: string;
+  password: string;
+  ssl?: boolean;
+  sslValidateCertificate?: boolean;
+  tags?: string[];
+};
+
+async function readCacheFile(): Promise<TConnectionsCacheFile> {
+  if (!(await fs.pathExists(CONNECTIONS_FILE_PATH))) {
+    return { connections: [] };
+  }
+
+  const parsed = await fs
+    .readJson(CONNECTIONS_FILE_PATH)
+    .catch(() => ({ connections: [] })) as Partial<TConnectionsCacheFile>;
+
+  return { connections: Array.isArray(parsed.connections) ? parsed.connections : [] };
+}
+
+async function writeCacheFile(cache: TConnectionsCacheFile): Promise<void> {
+  await fs.ensureDir(CACHE_DIRECTORY);
+  // Defensive: ensure every password is encrypted before persisting.
+  const secured: TConnectionsCacheFile = {
+    connections: cache.connections.map((connection) => ({
+      ...connection,
+      encryptedPassword: encryptSecret(connection.encryptedPassword),
+    })),
+  };
+  await fs.writeJson(CONNECTIONS_FILE_PATH, secured, { spaces: 2 });
+}
+
+function toPublicConnection(profile: TDatabaseConnectionProfile): TPublicDatabaseConnection {
+  const { encryptedPassword: _ignored, ...rest } = profile;
+  void _ignored;
+  return rest;
+}
+
+export async function listConnectionProfiles(): Promise<TDatabaseConnectionProfile[]> {
+  const cache = await readCacheFile();
+  return cache.connections;
+}
+
+export async function listPublicConnections(): Promise<TPublicDatabaseConnection[]> {
+  const cache = await readCacheFile();
+  return cache.connections
+    .map(toPublicConnection)
+    .sort((left, right) => (right.lastUsedAt ?? right.updatedAt).localeCompare(left.lastUsedAt ?? left.updatedAt));
+}
+
+export async function findConnectionProfile(id: string): Promise<TDatabaseConnectionProfile | undefined> {
+  const cache = await readCacheFile();
+  return cache.connections.find((connection) => connection.id === id);
+}
+
+export async function getResolvedConnection(id: string): Promise<TResolvedDatabaseConnection> {
+  const profile = await findConnectionProfile(id);
+
+  if (!profile) {
+    throw new Error(`Connection not found: ${id}`);
+  }
+
+  const { encryptedPassword, ...rest } = profile;
+  return { ...rest, password: decryptSecret(encryptedPassword) };
+}
+
+export async function upsertConnectionFromDraft(draft: TConnectionDraft): Promise<TDatabaseConnectionProfile> {
+  const cache = await readCacheFile();
+  const now = new Date().toISOString();
+
+  const existingIndex = draft.id
+    ? cache.connections.findIndex((connection) => connection.id === draft.id)
+    : cache.connections.findIndex((connection) =>
+        connection.app === draft.app &&
+        connection.serviceName === draft.serviceName &&
+        connection.type === draft.type &&
+        Boolean(draft.app) &&
+        Boolean(draft.serviceName));
+
+  const existing = existingIndex >= 0 ? cache.connections[existingIndex] : undefined;
+
+  const profile: TDatabaseConnectionProfile = {
+    id: existing?.id ?? draft.id ?? crypto.randomUUID(),
+    name: draft.name,
+    type: draft.type,
+    region: draft.region,
+    org: draft.org,
+    space: draft.space,
+    app: draft.app,
+    serviceName: draft.serviceName,
+    servicePlan: draft.servicePlan,
+    host: draft.host,
+    port: draft.port,
+    database: draft.database,
+    schema: draft.schema,
+    username: draft.username,
+    encryptedPassword: encryptSecret(draft.password),
+    ssl: draft.ssl,
+    sslValidateCertificate: draft.sslValidateCertificate,
+    tags: draft.tags,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    lastUsedAt: existing?.lastUsedAt,
+  };
+
+  if (existingIndex >= 0) {
+    cache.connections[existingIndex] = profile;
+  } else {
+    cache.connections.unshift(profile);
+  }
+
+  await writeCacheFile(cache);
+  return profile;
+}
+
+export async function removeConnection(id: string): Promise<boolean> {
+  const cache = await readCacheFile();
+  const nextConnections = cache.connections.filter((connection) => connection.id !== id);
+
+  if (nextConnections.length === cache.connections.length) {
+    return false;
+  }
+
+  await writeCacheFile({ connections: nextConnections });
+  return true;
+}
+
+export async function renameConnection(id: string, name: string): Promise<TDatabaseConnectionProfile> {
+  const cache = await readCacheFile();
+  const profile = cache.connections.find((connection) => connection.id === id);
+
+  if (!profile) {
+    throw new Error(`Connection not found: ${id}`);
+  }
+
+  profile.name = name;
+  profile.updatedAt = new Date().toISOString();
+  await writeCacheFile(cache);
+  return profile;
+}
+
+export async function duplicateConnection(id: string): Promise<TDatabaseConnectionProfile> {
+  const cache = await readCacheFile();
+  const source = cache.connections.find((connection) => connection.id === id);
+
+  if (!source) {
+    throw new Error(`Connection not found: ${id}`);
+  }
+
+  const now = new Date().toISOString();
+  const copy: TDatabaseConnectionProfile = {
+    ...source,
+    id: crypto.randomUUID(),
+    name: `${source.name} (copy)`,
+    createdAt: now,
+    updatedAt: now,
+    lastUsedAt: undefined,
+  };
+
+  cache.connections.unshift(copy);
+  await writeCacheFile(cache);
+  return copy;
+}
+
+export async function touchConnectionUsage(id: string): Promise<void> {
+  const cache = await readCacheFile();
+  const profile = cache.connections.find((connection) => connection.id === id);
+
+  if (!profile) {
+    return;
+  }
+
+  profile.lastUsedAt = new Date().toISOString();
+  await writeCacheFile(cache);
+}
+
+export function getConnectionsFilePath(): string {
+  return CONNECTIONS_FILE_PATH;
+}

package/src/core/db/db-connection.ts

@@ -0,0 +1,79 @@
+import { getResolvedConnection, touchConnectionUsage } from "./db-cache";
+import { HanaAdapter } from "./db-hana-adapter";
+import { PostgresAdapter } from "./db-postgres-adapter";
+import type { IDatabaseAdapter, TConnectionTestResult, TResolvedDatabaseConnection } from "./db-types";
+
+export function createAdapter(
+  connection: TResolvedDatabaseConnection,
+  options?: { queryTimeoutMs?: number },
+): IDatabaseAdapter {
+  switch (connection.type) {
+    case "hana":
+      return new HanaAdapter(connection, options);
+    case "postgresql":
+      return new PostgresAdapter(connection, options);
+    default:
+      throw new Error(`Unsupported database type: ${String(connection.type)}`);
+  }
+}
+
+export async function testConnectionProfile(
+  connection: TResolvedDatabaseConnection,
+  options?: { queryTimeoutMs?: number },
+): Promise<TConnectionTestResult> {
+  const adapter = createAdapter(connection, options);
+
+  try {
+    await adapter.connect();
+    return await adapter.testConnection();
+  } catch (error) {
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : String(error),
+      durationMs: 0,
+    };
+  } finally {
+    await adapter.disconnect();
+  }
+}
+
+/**
+ * Keeps one live adapter per connection id for the lifetime of a studio
+ * session, so repeated queries against the same connection reuse a single
+ * established session.
+ */
+export class StudioConnectionPool {
+  private readonly adapters = new Map<string, IDatabaseAdapter>();
+
+  constructor(private readonly options?: { queryTimeoutMs?: number }) {}
+
+  public async getAdapter(connectionId: string): Promise<IDatabaseAdapter> {
+    const existing = this.adapters.get(connectionId);
+
+    if (existing) {
+      return existing;
+    }
+
+    const resolved = await getResolvedConnection(connectionId);
+    const adapter = createAdapter(resolved, this.options);
+    await adapter.connect();
+    this.adapters.set(connectionId, adapter);
+    await touchConnectionUsage(connectionId).catch(() => undefined);
+    return adapter;
+  }
+
+  public async closeConnection(connectionId: string): Promise<void> {
+    const adapter = this.adapters.get(connectionId);
+
+    if (adapter) {
+      this.adapters.delete(connectionId);
+      await adapter.disconnect().catch(() => undefined);
+    }
+  }
+
+  public async closeAll(): Promise<void> {
+    const adapters = [...this.adapters.values()];
+    this.adapters.clear();
+    await Promise.all(adapters.map((adapter) => adapter.disconnect().catch(() => undefined)));
+  }
+}

package/src/core/db/db-crypto.ts

@@ -0,0 +1,53 @@
+import crypto from "node:crypto";
+import os from "node:os";
+
+const ENCRYPTION_PREFIX = "enc:";
+
+/**
+ * Derive a stable 256-bit key bound to the current user + machine. The key is
+ * never persisted; it is recomputed on demand. Cache files copied to another
+ * machine therefore cannot be decrypted, which is the intended behaviour.
+ */
+function deriveLocalKey(): Buffer {
+  const seed = `${os.userInfo().username}|${os.hostname()}|simplemdg-db`;
+  return crypto.createHash("sha256").update(seed).digest();
+}
+
+export function encryptSecret(plainValue: string): string {
+  if (plainValue.startsWith(ENCRYPTION_PREFIX)) {
+    return plainValue;
+  }
+
+  const key = deriveLocalKey();
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([cipher.update(plainValue, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+
+  return `${ENCRYPTION_PREFIX}${Buffer.concat([iv, authTag, encrypted]).toString("base64")}`;
+}
+
+export function decryptSecret(storedValue: string): string {
+  if (!storedValue.startsWith(ENCRYPTION_PREFIX)) {
+    // Backward compatibility: tolerate legacy plain values already on disk.
+    return storedValue;
+  }
+
+  try {
+    const key = deriveLocalKey();
+    const raw = Buffer.from(storedValue.slice(ENCRYPTION_PREFIX.length), "base64");
+    const iv = raw.subarray(0, 12);
+    const authTag = raw.subarray(12, 28);
+    const encrypted = raw.subarray(28);
+    const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(authTag);
+
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8");
+  } catch {
+    throw new Error("Cannot decrypt cached credential. It may have been created on another machine or user account. Re-import the connection.");
+  }
+}
+
+export function isEncrypted(value: string): boolean {
+  return value.startsWith(ENCRYPTION_PREFIX);
+}

package/src/core/db/db-hana-adapter.ts

@@ -0,0 +1,294 @@
+import { buildQualifiedName, quoteIdentifier } from "./db-metadata";
+import type {
+  IDatabaseAdapter,
+  TConnectionTestResult,
+  TDatabaseColumn,
+  TDatabaseIndex,
+  TDatabaseObject,
+  TDatabaseQueryResult,
+  TDatabaseSchema,
+  TDatabaseType,
+  TListObjectsOptions,
+  TResolvedDatabaseConnection,
+  TTableDataOptions,
+} from "./db-types";
+
+// Minimal typed surface for the untyped @sap/hana-client driver.
+interface IHanaConnection {
+  connect(options: Record<string, string>, callback: (error: Error | null) => void): void;
+  exec(sql: string, params: unknown[], callback: (error: Error | null, rows: unknown) => void): void;
+  disconnect(callback?: (error: Error | null) => void): void;
+}
+
+interface IHanaModule {
+  createConnection(): IHanaConnection;
+}
+
+const SYSTEM_SCHEMAS = new Set(["SYS", "SYSTEM", "_SYS_BIC", "_SYS_REPO", "_SYS_STATISTICS"]);
+const HANA_ROW_KIND = { TABLE: "table", VIEW: "view" } as const;
+
+type THanaRow = Record<string, unknown>;
+
+export class HanaAdapter implements IDatabaseAdapter {
+  public readonly type: TDatabaseType = "hana";
+
+  private connection: IHanaConnection | undefined;
+
+  private readonly queryTimeoutMs: number;
+
+  constructor(
+    private readonly resolvedConnection: TResolvedDatabaseConnection,
+    options?: { queryTimeoutMs?: number },
+  ) {
+    this.queryTimeoutMs = options?.queryTimeoutMs ?? 30000;
+  }
+
+  public async connect(): Promise<void> {
+    if (this.connection) {
+      return;
+    }
+
+    let hanaModule: IHanaModule;
+
+    try {
+      hanaModule = (await import("@sap/hana-client")) as unknown as IHanaModule;
+    } catch {
+      throw new Error("SAP HANA driver '@sap/hana-client' is not installed. Run: npm install @sap/hana-client");
+    }
+
+    const connection = hanaModule.createConnection();
+    const connectOptions: Record<string, string> = {
+      serverNode: `${this.resolvedConnection.host}:${this.resolvedConnection.port}`,
+      uid: this.resolvedConnection.username,
+      pwd: this.resolvedConnection.password,
+      encrypt: this.resolvedConnection.ssl === false ? "false" : "true",
+      sslValidateCertificate: this.resolvedConnection.sslValidateCertificate ? "true" : "false",
+      communicationTimeout: String(this.queryTimeoutMs),
+    };
+
+    if (this.resolvedConnection.schema) {
+      connectOptions.currentSchema = this.resolvedConnection.schema;
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      connection.connect(connectOptions, (error) => (error ? reject(error) : resolve()));
+    });
+
+    this.connection = connection;
+  }
+
+  public async disconnect(): Promise<void> {
+    if (this.connection) {
+      const connection = this.connection;
+      this.connection = undefined;
+      await new Promise<void>((resolve) => connection.disconnect(() => resolve()));
+    }
+  }
+
+  private async getConnection(): Promise<IHanaConnection> {
+    if (!this.connection) {
+      await this.connect();
+    }
+
+    if (!this.connection) {
+      throw new Error("SAP HANA connection is not established");
+    }
+
+    return this.connection;
+  }
+
+  private async exec(sql: string, params: unknown[] = []): Promise<unknown> {
+    const connection = await this.getConnection();
+    return new Promise<unknown>((resolve, reject) => {
+      connection.exec(sql, params, (error, rows) => (error ? reject(error) : resolve(rows)));
+    });
+  }
+
+  private async execRows(sql: string, params: unknown[] = []): Promise<THanaRow[]> {
+    const result = await this.exec(sql, params);
+    return Array.isArray(result) ? (result as THanaRow[]) : [];
+  }
+
+  public async testConnection(): Promise<TConnectionTestResult> {
+    const startedAt = Date.now();
+
+    try {
+      const rows = await this.execRows("SELECT VERSION FROM SYS.M_DATABASE");
+      const version = String(rows[0]?.VERSION ?? "SAP HANA");
+      return { success: true, message: "Connection successful", serverVersion: version, durationMs: Date.now() - startedAt };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - startedAt,
+      };
+    }
+  }
+
+  private toQueryResult(result: unknown, durationMs: number, maxRows?: number): TDatabaseQueryResult {
+    if (typeof result === "number") {
+      return { fields: [], rows: [], rowCount: 0, affectedRows: result, command: "DML", durationMs };
+    }
+
+    const allRows = Array.isArray(result) ? (result as THanaRow[]) : [];
+    const limit = maxRows ?? 0;
+    const truncated = limit > 0 && allRows.length > limit;
+    const rows = truncated ? allRows.slice(0, limit) : allRows;
+
+    return {
+      fields: rows.length > 0 ? Object.keys(rows[0]) : [],
+      rows,
+      rowCount: rows.length,
+      command: "SELECT",
+      durationMs,
+      truncated,
+    };
+  }
+
+  public async runQuery(sql: string, options?: { maxRows?: number }): Promise<TDatabaseQueryResult> {
+    const startedAt = Date.now();
+    const result = await this.exec(sql);
+    return this.toQueryResult(result, Date.now() - startedAt, options?.maxRows);
+  }
+
+  public async runParameterized(sql: string, params: unknown[], options?: { maxRows?: number }): Promise<TDatabaseQueryResult> {
+    const startedAt = Date.now();
+    const result = await this.exec(sql, params);
+    return this.toQueryResult(result, Date.now() - startedAt, options?.maxRows);
+  }
+
+  public placeholder(_index: number): string {
+    return "?";
+  }
+
+  public async listSchemas(): Promise<TDatabaseSchema[]> {
+    const rows = await this.execRows("SELECT SCHEMA_NAME FROM SYS.SCHEMAS ORDER BY SCHEMA_NAME");
+    return rows.map((row) => {
+      const name = String(row.SCHEMA_NAME);
+      return { name, isSystem: SYSTEM_SCHEMAS.has(name) || name.startsWith("_SYS") };
+    });
+  }
+
+  public async listObjects(options: TListObjectsOptions): Promise<TDatabaseObject[]> {
+    const schema = options.schema;
+
+    if (!schema) {
+      return [];
+    }
+
+    const kinds = options.kinds;
+    const objects: TDatabaseObject[] = [];
+
+    if (!kinds || kinds.includes("table")) {
+      const tables = await this.execRows("SELECT TABLE_NAME FROM SYS.TABLES WHERE SCHEMA_NAME = ? ORDER BY TABLE_NAME", [schema]);
+      objects.push(...tables.map((row) => ({ schema, name: String(row.TABLE_NAME), kind: HANA_ROW_KIND.TABLE })));
+    }
+
+    if (!kinds || kinds.includes("view") || kinds.includes("column-view")) {
+      const views = await this.execRows("SELECT VIEW_NAME FROM SYS.VIEWS WHERE SCHEMA_NAME = ? ORDER BY VIEW_NAME", [schema]);
+      objects.push(...views.map((row) => ({ schema, name: String(row.VIEW_NAME), kind: HANA_ROW_KIND.VIEW })));
+    }
+
+    if (!kinds || kinds.includes("procedure")) {
+      const procedures = await this.execRows("SELECT PROCEDURE_NAME FROM SYS.PROCEDURES WHERE SCHEMA_NAME = ? ORDER BY PROCEDURE_NAME", [schema]);
+      objects.push(...procedures.map((row) => ({ schema, name: String(row.PROCEDURE_NAME), kind: "procedure" as const })));
+    }
+
+    if (!kinds || kinds.includes("function")) {
+      const functions = await this.execRows("SELECT FUNCTION_NAME FROM SYS.FUNCTIONS WHERE SCHEMA_NAME = ? ORDER BY FUNCTION_NAME", [schema]);
+      objects.push(...functions.map((row) => ({ schema, name: String(row.FUNCTION_NAME), kind: "function" as const })));
+    }
+
+    if (!kinds || kinds.includes("synonym")) {
+      const synonyms = await this.execRows("SELECT SYNONYM_NAME FROM SYS.SYNONYMS WHERE SCHEMA_NAME = ? ORDER BY SYNONYM_NAME", [schema]).catch(() => []);
+      objects.push(...synonyms.map((row) => ({ schema, name: String(row.SYNONYM_NAME), kind: "synonym" as const })));
+    }
+
+    const search = options.search?.trim().toLowerCase();
+    return search ? objects.filter((object) => object.name.toLowerCase().includes(search)) : objects;
+  }
+
+  public async listColumns(schema: string, table: string): Promise<TDatabaseColumn[]> {
+    const primaryKeyRows = await this.execRows(
+      "SELECT COLUMN_NAME FROM SYS.CONSTRAINTS WHERE SCHEMA_NAME = ? AND TABLE_NAME = ? AND IS_PRIMARY_KEY = 'TRUE'",
+      [schema, table],
+    ).catch(() => []);
+    const primaryKeyColumns = new Set(primaryKeyRows.map((row) => String(row.COLUMN_NAME)));
+
+    const tableColumns = await this.execRows(
+      `SELECT COLUMN_NAME, DATA_TYPE_NAME, LENGTH, SCALE, IS_NULLABLE, DEFAULT_VALUE, POSITION, COMMENTS
+       FROM SYS.TABLE_COLUMNS WHERE SCHEMA_NAME = ? AND TABLE_NAME = ? ORDER BY POSITION`,
+      [schema, table],
+    );
+
+    const columns = tableColumns.length > 0
+      ? tableColumns
+      : await this.execRows(
+          `SELECT COLUMN_NAME, DATA_TYPE_NAME, LENGTH, SCALE, IS_NULLABLE, DEFAULT_VALUE, POSITION
+           FROM SYS.VIEW_COLUMNS WHERE SCHEMA_NAME = ? AND VIEW_NAME = ? ORDER BY POSITION`,
+          [schema, table],
+        ).catch(() => []);
+
+    return columns.map((row) => ({
+      name: String(row.COLUMN_NAME),
+      dataType: String(row.DATA_TYPE_NAME),
+      length: row.LENGTH === null || row.LENGTH === undefined ? undefined : Number(row.LENGTH),
+      scale: row.SCALE === null || row.SCALE === undefined ? undefined : Number(row.SCALE),
+      nullable: String(row.IS_NULLABLE).toUpperCase() === "TRUE",
+      defaultValue: row.DEFAULT_VALUE === null || row.DEFAULT_VALUE === undefined ? undefined : String(row.DEFAULT_VALUE),
+      isPrimaryKey: primaryKeyColumns.has(String(row.COLUMN_NAME)),
+      comment: row.COMMENTS === null || row.COMMENTS === undefined ? undefined : String(row.COMMENTS),
+      position: Number(row.POSITION),
+    }));
+  }
+
+  public async listIndexes(schema: string, table: string): Promise<TDatabaseIndex[]> {
+    const indexes = await this.execRows(
+      "SELECT INDEX_NAME, INDEX_TYPE, CONSTRAINT FROM SYS.INDEXES WHERE SCHEMA_NAME = ? AND TABLE_NAME = ?",
+      [schema, table],
+    ).catch(() => []);
+
+    const result: TDatabaseIndex[] = [];
+
+    for (const indexRow of indexes) {
+      const indexName = String(indexRow.INDEX_NAME);
+      const columnRows = await this.execRows(
+        "SELECT COLUMN_NAME FROM SYS.INDEX_COLUMNS WHERE SCHEMA_NAME = ? AND TABLE_NAME = ? AND INDEX_NAME = ? ORDER BY POSITION",
+        [schema, table, indexName],
+      ).catch(() => []);
+      const constraint = String(indexRow.CONSTRAINT ?? "");
+
+      result.push({
+        name: indexName,
+        columns: columnRows.map((row) => String(row.COLUMN_NAME)),
+        isUnique: /UNIQUE/i.test(constraint) || /UNIQUE/i.test(String(indexRow.INDEX_TYPE ?? "")),
+        isPrimaryKey: /PRIMARY KEY/i.test(constraint),
+      });
+    }
+
+    return result;
+  }
+
+  public async countRows(schema: string, table: string): Promise<number> {
+    const rows = await this.execRows(`SELECT COUNT(*) AS ROW_COUNT FROM ${buildQualifiedName(this.type, schema, table)}`);
+    return Number(rows[0]?.ROW_COUNT ?? 0);
+  }
+
+  public async getTableData(options: TTableDataOptions): Promise<TDatabaseQueryResult> {
+    const qualifiedName = buildQualifiedName(this.type, options.schema, options.table);
+    const whereClause = options.where?.trim() ? ` WHERE ${options.where.trim()}` : "";
+    const orderClause = options.orderBy?.trim()
+      ? ` ORDER BY ${quoteIdentifier(this.type, options.orderBy.trim())} ${options.orderDirection === "desc" ? "DESC" : "ASC"}`
+      : "";
+    const sql = `SELECT * FROM ${qualifiedName}${whereClause}${orderClause} LIMIT ${options.limit} OFFSET ${options.offset}`;
+    return this.runQuery(sql, { maxRows: options.limit });
+  }
+
+  public quoteIdentifier(identifier: string): string {
+    return quoteIdentifier(this.type, identifier);
+  }
+
+  public buildQualifiedName(schema: string, name: string): string {
+    return buildQualifiedName(this.type, schema, name);
+  }
+}