dbgate-types 6.1.5 → 6.2.0

package/dbinfo.d.ts

@@ -163,7 +163,7 @@ export interface SchedulerEventInfo extends SqlObjectInfo {
   onCompletion: 'PRESERVE' | 'NOT PRESERVE';
   status: 'ENABLED' | 'DISABLED';
   lastExecuted?: string;
-  intervalValue: number;
+  intervalValue: string;
   intervalField: string;
   starts: string;
   executeAt: string;
@@ -189,3 +189,34 @@ export interface DatabaseInfoObjects {
 export interface DatabaseInfo extends DatabaseInfoObjects {
   engine?: string;
 }
+
+export interface ColumnReferenceTiny {
+  n: string; // name
+  r?: string; // ref name
+}
+
+export interface PrimaryKeyInfoTiny {
+  c: ColumnReferenceTiny[]; // columns
+}
+
+export interface ForeignKeyInfoTiny {
+  c: ColumnReferenceTiny[]; // columns
+  r: string; // reference table name
+}
+
+export interface ColumnInfoTiny {
+  n: string; // name
+  t: string; // type
+}
+
+export interface TableInfoTiny {
+  n: string; //name
+  o: string; // comment
+  c: ColumnInfoTiny[]; // columns
+  p?: PrimaryKeyInfoTiny; // primary key
+  f?: ForeignKeyInfoTiny[]; // foreign keys
+}
+
+export interface DatabaseInfoTiny {
+  t: TableInfoTiny[]; // tables
+}

package/dialect.d.ts

@@ -1,3 +1,5 @@
+import { ColumnInfo } from './dbinfo';
+
 export interface SqlDialect {
   rangeSelect?: boolean;
   limitSelect?: boolean;
@@ -6,6 +8,7 @@ export interface SqlDialect {
   topRecords?: boolean;
   stringEscapeChar: string;
   offsetFetchRangeSyntax?: boolean;
+  offsetNotSupported?: boolean;
   quoteIdentifier(s: string): string;
   fallbackDataType?: string;
   explicitDropConstraint?: boolean;
@@ -44,7 +47,14 @@ export interface SqlDialect {
   omitForeignKeys?: boolean;
   omitUniqueConstraints?: boolean;
   omitIndexes?: boolean;
+  omitTableAliases?: boolean;
+  omitTableBeforeColumn?: boolean;
+  disableAutoIncrement?: boolean;
+  disableNonPrimaryKeyRename?: boolean;
+  disableRenameTable?: boolean;
+  defaultNewTableColumns?: ColumnInfo[];
   sortingKeys?: boolean;
+  generateDefaultValueForUuid?: string;
 
   // syntax for create column: ALTER TABLE table ADD COLUMN column
   createColumnWithColumnKeyword?: boolean;

package/dumper.d.ts

@@ -11,7 +11,7 @@ export interface SqlDumper extends AlterProcessor {
   putRaw(s: string);
   put(format: string, ...args);
   putCmd(format: string, ...args);
-  putValue(value: string | number | Date);
+  putValue(value: string | number | Date, dataType?: string);
   putCollection<T>(delimiter: string, collection: T[], lambda: (item: T) => void);
   transform(type: TransformType, dumpExpr: () => void);
   createDatabase(name: string);

package/engines.d.ts

@@ -32,6 +32,7 @@ export interface RunScriptOptions {
 export interface QueryOptions {
   discardResult?: boolean;
   importSqlDump?: boolean;
+  range?: { offset: number; limit: number };
 }
 
 export interface WriteTableOptions {
@@ -133,8 +134,8 @@ export interface FilterBehaviourProvider {
   getFilterBehaviour(dataType: string, standardFilterBehaviours: { [id: string]: FilterBehaviour }): FilterBehaviour;
 }
 
-export interface DatabaseHandle {
-  client: any;
+export interface DatabaseHandle<TClient = any> {
+  client: TClient;
   database?: string;
   feedback?: (message: any) => void;
   getDatabase?: () => any;
@@ -142,7 +143,7 @@ export interface DatabaseHandle {
   treeKeySeparator?: string;
 }
 
-export interface EngineDriver extends FilterBehaviourProvider {
+export interface EngineDriver<TClient = any> extends FilterBehaviourProvider {
   engine: string;
   title: string;
   defaultPort?: number;
@@ -180,57 +181,68 @@ export interface EngineDriver extends FilterBehaviourProvider {
   beforeConnectionSave?: (values: any) => any;
   databaseUrlPlaceholder?: string;
   defaultAuthTypeName?: string;
+  defaultLocalDataCenter?: string;
   defaultSocketPath?: string;
   authTypeLabel?: string;
   importExportArgs?: any[];
-  connect({ server, port, user, password, database }): Promise<DatabaseHandle>;
-  close(dbhan: DatabaseHandle): Promise<any>;
-  query(dbhan: DatabaseHandle, sql: string, options?: QueryOptions): Promise<QueryResult>;
-  stream(dbhan: DatabaseHandle, sql: string, options: StreamOptions);
-  readQuery(dbhan: DatabaseHandle, sql: string, structure?: TableInfo): Promise<stream.Readable>;
-  readJsonQuery(dbhan: DatabaseHandle, query: any, structure?: TableInfo): Promise<stream.Readable>;
+  connect({ server, port, user, password, database }): Promise<DatabaseHandle<TClient>>;
+  close(dbhan: DatabaseHandle<TClient>): Promise<any>;
+  query(dbhan: DatabaseHandle<TClient>, sql: string, options?: QueryOptions): Promise<QueryResult>;
+  stream(dbhan: DatabaseHandle<TClient>, sql: string, options: StreamOptions);
+  readQuery(dbhan: DatabaseHandle<TClient>, sql: string, structure?: TableInfo): Promise<stream.Readable>;
+  readJsonQuery(dbhan: DatabaseHandle<TClient>, query: any, structure?: TableInfo): Promise<stream.Readable>;
   // eg. PostgreSQL COPY FROM stdin
-  writeQueryFromStream(dbhan: DatabaseHandle, sql: string): Promise<stream.Writable>;
-  writeTable(dbhan: DatabaseHandle, name: NamedObjectInfo, options: WriteTableOptions): Promise<stream.Writable>;
+  writeQueryFromStream(dbhan: DatabaseHandle<TClient>, sql: string): Promise<stream.Writable>;
+  writeTable(
+    dbhan: DatabaseHandle<TClient>,
+    name: NamedObjectInfo,
+    options: WriteTableOptions
+  ): Promise<stream.Writable>;
   analyseSingleObject(
-    dbhan: DatabaseHandle,
+    dbhan: DatabaseHandle<TClient>,
     name: NamedObjectInfo,
     objectTypeField: keyof DatabaseInfo
   ): Promise<TableInfo | ViewInfo | ProcedureInfo | FunctionInfo | TriggerInfo>;
-  analyseSingleTable(dbhan: DatabaseHandle, name: NamedObjectInfo): Promise<TableInfo>;
-  getVersion(dbhan: DatabaseHandle): Promise<{ version: string; versionText?: string }>;
-  listDatabases(dbhan: DatabaseHandle): Promise<
+  analyseSingleTable(dbhan: DatabaseHandle<TClient>, name: NamedObjectInfo): Promise<TableInfo>;
+  getVersion(dbhan: DatabaseHandle<TClient>): Promise<{ version: string; versionText?: string }>;
+  listDatabases(dbhan: DatabaseHandle<TClient>): Promise<
     {
       name: string;
     }[]
   >;
-  loadKeys(dbhan: DatabaseHandle, root: string, filter?: string): Promise;
-  exportKeys(dbhan: DatabaseHandle, options: {}): Promise;
-  loadKeyInfo(dbhan: DatabaseHandle, key): Promise;
-  loadKeyTableRange(dbhan: DatabaseHandle, key, cursor, count): Promise;
-  loadFieldValues(dbhan: DatabaseHandle, name: NamedObjectInfo, field: string, search: string): Promise;
-  analyseFull(dbhan: DatabaseHandle, serverVersion): Promise<DatabaseInfo>;
-  analyseIncremental(dbhan: DatabaseHandle, structure: DatabaseInfo, serverVersion): Promise<DatabaseInfo>;
+  loadKeys(dbhan: DatabaseHandle<TClient>, root: string, filter?: string): Promise;
+  exportKeys(dbhan: DatabaseHandle<TClient>, options: {}): Promise;
+  loadKeyInfo(dbhan: DatabaseHandle<TClient>, key): Promise;
+  loadKeyTableRange(dbhan: DatabaseHandle<TClient>, key, cursor, count): Promise;
+  loadFieldValues(
+    dbhan: DatabaseHandle<TClient>,
+    name: NamedObjectInfo,
+    field: string,
+    search: string,
+    dataType: string
+  ): Promise;
+  analyseFull(dbhan: DatabaseHandle<TClient>, serverVersion): Promise<DatabaseInfo>;
+  analyseIncremental(dbhan: DatabaseHandle<TClient>, structure: DatabaseInfo, serverVersion): Promise<DatabaseInfo>;
   dialect: SqlDialect;
   dialectByVersion(version): SqlDialect;
   createDumper(options = null): SqlDumper;
-  createBackupDumper(dbhan: DatabaseHandle, options): Promise<SqlBackupDumper>;
+  createBackupDumper(dbhan: DatabaseHandle<TClient>, options): Promise<SqlBackupDumper>;
   getAuthTypes(): EngineAuthType[];
-  readCollection(dbhan: DatabaseHandle, options: ReadCollectionOptions): Promise<any>;
-  updateCollection(dbhan: DatabaseHandle, changeSet: any): Promise<any>;
+  readCollection(dbhan: DatabaseHandle<TClient>, options: ReadCollectionOptions): Promise<any>;
+  updateCollection(dbhan: DatabaseHandle<TClient>, changeSet: any): Promise<any>;
   getCollectionUpdateScript(changeSet: any, collectionInfo: CollectionInfo): string;
-  createDatabase(dbhan: DatabaseHandle, name: string): Promise;
-  dropDatabase(dbhan: DatabaseHandle, name: string): Promise;
+  createDatabase(dbhan: DatabaseHandle<TClient>, name: string): Promise;
+  dropDatabase(dbhan: DatabaseHandle<TClient>, name: string): Promise;
   getQuerySplitterOptions(usage: 'stream' | 'script' | 'editor' | 'import'): any;
-  script(dbhan: DatabaseHandle, sql: string, options?: RunScriptOptions): Promise;
-  operation(dbhan: DatabaseHandle, operation: {}, options?: RunScriptOptions): Promise;
+  script(dbhan: DatabaseHandle<TClient>, sql: string, options?: RunScriptOptions): Promise;
+  operation(dbhan: DatabaseHandle<TClient>, operation: {}, options?: RunScriptOptions): Promise;
   getNewObjectTemplates(): NewObjectTemplate[];
   // direct call of dbhan.client method, only some methods could be supported, on only some drivers
-  callMethod(dbhan: DatabaseHandle, method, args);
-  serverSummary(dbhan: DatabaseHandle): Promise<ServerSummary>;
-  summaryCommand(dbhan: DatabaseHandle, command, row): Promise<void>;
-  startProfiler(dbhan: DatabaseHandle, options): Promise<any>;
-  stopProfiler(dbhan: DatabaseHandle, profiler): Promise<void>;
+  callMethod(dbhan: DatabaseHandle<TClient>, method, args);
+  serverSummary(dbhan: DatabaseHandle<TClient>): Promise<ServerSummary>;
+  summaryCommand(dbhan: DatabaseHandle<TClient>, command, row): Promise<void>;
+  startProfiler(dbhan: DatabaseHandle<TClient>, options): Promise<any>;
+  stopProfiler(dbhan: DatabaseHandle<TClient>, profiler): Promise<void>;
   getRedirectAuthUrl(connection, options): Promise<{ url: string; sid: string }>;
   getAuthTokenFromCode(connection, options): Promise<string>;
   getAccessTokenFromAuth(connection, req): Promise<string | null>;
@@ -241,11 +253,11 @@ export interface EngineDriver extends FilterBehaviourProvider {
   createSaveChangeSetScript(
     changeSet: any,
     dbinfo: DatabaseInfo,
-    defaultCreator: (changeSet: any, dbinfo: DatabaseInfo) => any
+    defaultCreator: (changeSet: any, dbinfo: DatabaseInfo, dialect: SqlDialect) => any
   ): any[];
   // adapts table info from different source (import, other database) to be suitable for this database
   adaptTableInfo(table: TableInfo): TableInfo;
-  listSchemas(dbhan: DatabaseHandle): SchemaInfo[];
+  listSchemas(dbhan: DatabaseHandle<TClient>): SchemaInfo[];
 
   analyserClass?: any;
   dumperClass?: any;

package/index.d.ts

@@ -48,3 +48,4 @@ export * from './extensions';
 export * from './alter-processor';
 export * from './appdefs';
 export * from './filter-type';
+export * from './test-engines';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "6.1.5",
+  "version": "6.2.0",
   "name": "dbgate-types",
   "homepage": "https://dbgate.org/",
   "repository": {

package/test-engines.d.ts

@@ -0,0 +1,86 @@
+import { ParameterInfo, SchedulerEventInfo, TriggerInfo } from './dbinfo';
+
+export type TestObjectInfo = {
+  type: string;
+  create1: string;
+  create2: string;
+  drop1: string;
+  drop2: string;
+};
+
+export type TestEngineInfo = {
+  label: string;
+  connection: {
+    engine: string;
+    server?: string;
+    databaseUrl?: string;
+    serviceName?: string;
+    password?: string;
+    user?: string;
+    port?: number;
+  };
+
+  removeNotNull?: boolean;
+
+  skipOnCI?: boolean;
+  skipIncrementalAnalysis?: boolean;
+  skipDataModifications?: boolean;
+  skipReferences?: boolean;
+  skipIndexes?: boolean;
+  skipNullability?: boolean;
+  skipUnique?: boolean;
+  skipAutoIncrement?: boolean;
+  skipPkColumnTesting?: boolean;
+  skipDataDuplicator?: boolean;
+  skipDeploy?: boolean;
+  skipStringLength?: boolean;
+  skipChangeColumn?: boolean;
+  skipDefaultValue?: boolean;
+  skipNonPkRename?: boolean;
+  skipPkDrop?: boolean;
+  skipOrderBy?: boolean;
+
+  forceSortResults?: boolean;
+  forceSortStructureColumns?: boolean;
+  alterTableAddColumnSyntax?: boolean;
+  dbSnapshotBySeconds?: boolean;
+  setNullDefaultInsteadOfDrop?: boolean;
+
+  useTextTypeForStrings?: boolean;
+
+  supportRenameSqlObject?: boolean;
+  supportSchemas?: boolean;
+
+  defaultSchemaName?: string;
+
+  generateDbFile?: boolean;
+  dbSnapshotBySeconds?: boolean;
+  dumpFile?: string;
+  dumpChecks?: Array<{ sql: string; res: string }>;
+
+  parametersOtherSql?: string[];
+  parameters?: Array<{
+    testName: string;
+    create: string;
+    drop: string;
+    objectTypeField: string;
+    list: Array<Partial<ParameterInfo>>;
+  }>;
+  triggers?: Array<{
+    testName: string;
+    create: string;
+    drop: string;
+    triggerOtherCreateSql?: string;
+    triggerOtherDropSql?: string;
+    objectTypeField: string;
+    expected: Partial<TriggerInfo>;
+  }>;
+  schedulerEvents?: Array<{
+    create: string;
+    drop: string;
+    objectTypeField: string;
+    expected: Partial<SchedulerEventInfo>;
+  }>;
+
+  objects?: Array<TestObjectInfo>;
+};