@or-sdk/pgsql 0.22.5-244.0

package/dist/types/types.d.ts

@@ -0,0 +1,110 @@
+import { Token } from '@or-sdk/base';
+export declare type PgsqlConfig = {
+    token: Token;
+    discoveryUrl?: string;
+    accountId?: string;
+    pgsqlUrl?: string;
+};
+export declare type QueryField = {
+    name: string;
+    tableID: number;
+    columnID: number;
+    dataTypeID: number;
+    dataTypeSize: number;
+    dataTypeModifier: number;
+    format: string;
+};
+export declare type ExecuteQueryResponse<T> = {
+    command: string;
+    rowCount: null | number;
+    oid: null | number;
+    rows: T[];
+    fields: QueryField[];
+    RowCtor: null | unknown;
+    rowAsArray: boolean;
+};
+export declare type ExecuteQueryArgs = {
+    query: string;
+    params?: {
+        [key: string]: unknown;
+    };
+    database: string;
+};
+export declare type CreateDatabaseResponse = {
+    ok: number;
+    result: [
+        unknown[],
+        unknown[]
+    ];
+};
+export declare type ListDatabasesResponseItem = {
+    name: string;
+};
+export declare type ListDatabasesResponse = {
+    databases: ListDatabasesResponseItem[];
+};
+export declare type DropDatabaseResponse = {
+    ok?: number;
+};
+export declare type GetDBSizeResult = {
+    usedSize: number;
+    sizeLimit: string | number;
+};
+export declare type TableColumn = {
+    name: string;
+    type: number;
+};
+export declare type CreateTableArgs = {
+    database: string;
+    schema: string;
+    table: string;
+    columns: TableColumn[];
+    primaryKey: string;
+};
+export declare type AddColumnsArgs = {
+    database: string;
+    schema: string;
+    table: string;
+    columns: TableColumn[];
+};
+export declare type Row = {
+    [key: string]: unknown;
+};
+export declare type InsertArgs = {
+    database: string;
+    schema: string;
+    table: string;
+    rows: Row[];
+    chunkSize: number;
+    context?: {
+        progress?: number;
+    };
+};
+export declare type EncodedValue = string | number | boolean;
+export declare type SelectAllArgs = {
+    database: string;
+    query: string;
+    context?: {
+        progress?: number;
+        total?: number;
+    };
+    chunkSize?: number;
+    offset?: number;
+    limit?: number;
+};
+export declare type EditRowArgs = {
+    database: string;
+    schema: string;
+    table: string;
+    key: string;
+    value: unknown;
+    row: Row;
+    primaryKeys: string;
+};
+export declare type DeleteRowsArgs = {
+    database: string;
+    schema: string;
+    table: string;
+    rows: Row[];
+    primaryKeys: string;
+};

package/dist/types/utils/createSchemaQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string) => string;
+export default _default;

package/dist/types/utils/encodeValue.d.ts

@@ -0,0 +1,3 @@
+import { EncodedValue } from '../types';
+declare function encodeValue(value: unknown): EncodedValue;
+export default encodeValue;

package/dist/types/utils/extractDatabaseNames.d.ts

@@ -0,0 +1,3 @@
+import { ListDatabasesResponseItem } from '../types';
+declare function extractDatabaseNames(databaseNameArr: ListDatabasesResponseItem[]): string[];
+export default extractDatabaseNames;

package/dist/types/utils/getAddColumnsQuery.d.ts

@@ -0,0 +1,3 @@
+import { TableColumn } from '../types';
+declare const _default: (schema: string, table: string, columns: TableColumn[]) => string;
+export default _default;

package/dist/types/utils/getCreateTableQuery.d.ts

@@ -0,0 +1,3 @@
+import { TableColumn } from '../types';
+declare const _default: (schema: string, table: string, columns: TableColumn[], primaryKey: string) => string;
+export default _default;

package/dist/types/utils/getDeleteRowsQuery.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '../types';
+declare function getDeleteRowQuery(schema: string, table: string, rows: Row[], primaryKeys: string): string;
+export default getDeleteRowQuery;

package/dist/types/utils/getDropSchemaQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string) => string;
+export default _default;

package/dist/types/utils/getDropTableQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string, table: string) => string;
+export default _default;

package/dist/types/utils/getEditRowQuery.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '../types';
+declare function getEditRowQuery(schema: string, table: string, key: string, value: unknown, row: Row, primaryKeys: string): string;
+export default getEditRowQuery;

package/dist/types/utils/getGenerateTableSchemaQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string, table: string) => string;
+export default _default;

package/dist/types/utils/getGetPrimaryKeysQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string, table: string) => string;
+export default _default;

package/dist/types/utils/getInsertKeys.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '../types';
+declare function getInsertKeys(rows: Row[]): string[];
+export default getInsertKeys;

package/dist/types/utils/getInsertQueries.d.ts

@@ -0,0 +1,3 @@
+import { Row } from '../types';
+declare function getInsertQueries(schema: string, table: string, insertRows: Row[], chunkSize: number): string[];
+export default getInsertQueries;

package/dist/types/utils/getListTablesQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (schema: string) => string;
+export default _default;

package/dist/types/utils/getSelectAllCountQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (query: string) => string;
+export default _default;

package/dist/types/utils/getSelectAllQuery.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (query: string, offset: number, chunkSize: number) => string;
+export default _default;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,17 @@
+export { default as extractDatabaseNames } from './extractDatabaseNames';
+export { default as getInsertKeys } from './getInsertKeys';
+export { default as encodeValue } from './encodeValue';
+export { default as splitPrimaryKeys } from './splitPrimaryKeys';
+export { default as getListTablesQuery } from './getListTablesQuery';
+export { default as createSchemaQuery } from './createSchemaQuery';
+export { default as getDropSchemaQuery } from './getDropSchemaQuery';
+export { default as getCreateTableQuery } from './getCreateTableQuery';
+export { default as getDropTableQuery } from './getDropTableQuery';
+export { default as getAddColumnsQuery } from './getAddColumnsQuery';
+export { default as getInsertQueries } from './getInsertQueries';
+export { default as getSelectAllCountQuery } from './getSelectAllCountQuery';
+export { default as getSelectAllQuery } from './getSelectAllQuery';
+export { default as getEditRowQuery } from './getEditRowQuery';
+export { default as getDeleteRowsQuery } from './getDeleteRowsQuery';
+export { default as getGenerateTableSchemaQuery } from './getGenerateTableSchemaQuery';
+export { default as getGetPrimaryKeysQuery } from './getGetPrimaryKeysQuery';

package/dist/types/utils/splitPrimaryKeys.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (primaryKeys: string) => string[];
+export default _default;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "version": "0.22.5-244.0",
+  "name": "@or-sdk/pgsql",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && concurrently \"npm run build:cjs\" \"npm run build:esm\" \"npm run build:types\"",
+    "build:watch": "concurrently -r --hide 1,2 \"npm run build:watch:cjs\" \"npm run build:watch:esm\" \"npm run build:watch:types\"",
+    "build:cjs": "tsc --project tsconfig.json",
+    "build:watch:cjs": "tsc --project tsconfig.json -w",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "build:watch:esm": "tsc --project tsconfig.esm.json -w",
+    "build:types": "tsc --project tsconfig.types.json",
+    "build:watch:types": "tsc --project tsconfig.types.json -w",
+    "clean": "rm -rf ./dist"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.176",
+    "concurrently": "^6.4.0",
+    "typescript": "^4.4.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@or-sdk/base": "^0.22.4",
+    "lodash": "^4.17.21"
+  }
+}

package/src/Pgsql.ts

@@ -0,0 +1,405 @@
+import { Base, ServiceDiscoveryResponse, List, makeList } from '@or-sdk/base';
+import {
+  AddColumnsArgs,
+  CreateDatabaseResponse, CreateTableArgs, DeleteRowsArgs, DropDatabaseResponse, EditRowArgs,
+  ExecuteQueryArgs, ExecuteQueryResponse, GetDBSizeResult, InsertArgs,
+  ListDatabasesResponse,
+  PgsqlConfig, Row, SelectAllArgs,
+} from './types';
+import { LIST_SCHEMAS_QUERY, SERVICE_KEY } from './constants';
+import {
+  extractDatabaseNames, getAddColumnsQuery,
+  getCreateTableQuery,
+  getDropSchemaQuery,
+  getDropTableQuery, getEditRowQuery, getGenerateTableSchemaQuery, getInsertQueries,
+  getListTablesQuery, getSelectAllCountQuery, getSelectAllQuery,
+  getDeleteRowsQuery, createSchemaQuery, getGetPrimaryKeysQuery,
+} from './utils';
+
+/**
+ * OneReach Pgsql service client
+ *  ## Installation:
+ * ```
+ * $ npm i @or-sdk/pgsql
+ * ```
+ */
+export class Pgsql extends Base {
+  /**
+   * ```typescript
+   * import { Pgsql } from '@or-sdk/pgsql'
+   * const pgsql = new Pgsql({token: 'my-account-token-string', discoveryUrl: 'http://example.pgsql/endpoint'});
+   * ```
+   */
+  constructor(params: PgsqlConfig) {
+    const { token, discoveryUrl, accountId, pgsqlUrl } = params;
+
+    super({
+      token,
+      discoveryUrl,
+      serviceKey: SERVICE_KEY,
+      accountId,
+      serviceUrl: pgsqlUrl,
+    });
+  }
+
+  makeApiUrl(data: ServiceDiscoveryResponse): string {
+    return this.isCrossAccount
+      ? `${data.url}/${this.targetAccountId}`
+      : `${data.url}/current`;
+  }
+
+  /**
+   * Execute query
+   * ```typescript
+   * const result = await pgsql.executeQuery({
+   *   query: 'select * from table',
+   *   database: 'db-name'
+   * });
+   * ```
+   */
+  public async executeQuery<T>({ query, params, database }: ExecuteQueryArgs): Promise<ExecuteQueryResponse<T>> {
+    return this.callApi<ExecuteQueryResponse<T>>({
+      data: {
+        query,
+        params,
+        database,
+      },
+      method: 'POST',
+      route: 'query',
+    });
+  }
+
+  /**
+   * List databases
+   * ```typescript
+   * const databaseList = await pgsql.listDatabases();
+   * ```
+   */
+  public async listDatabases(): Promise<List<string>> {
+    const { databases } = await this.callApi<ListDatabasesResponse>({
+      method: 'GET',
+      route: 'databases',
+    });
+
+    return makeList<string>(extractDatabaseNames(databases));
+  }
+
+  /**
+   * Create database
+   * ```typescript
+   * const result = await pgsql.createDatabase({ database: 'db-name' });
+   * ```
+   */
+  public async createDatabase({ database }: { database: string; }): Promise<CreateDatabaseResponse> {
+    return this.callApi<CreateDatabaseResponse>({
+      data: { database },
+      method: 'PUT',
+      route: 'databases',
+    });
+  }
+
+  /**
+   * Get database info
+   *
+   * @deprecated route not available
+   * ```typescript
+   * const result = await pgsql.getDatabaseInfo({ database: 'db-name' });
+   * ```
+   */
+  // TODO: uncomment or replace route?
+  // public async getDatabaseInfo({ database }: { database: string; }): Promise<unknown> {
+  //   return this.callApi<unknown>({
+  //     method: 'GET',
+  //     route: `databases/${encodeURIComponent(database)}`
+  //   })
+  // }
+
+  /**
+   * Drop database
+   * ```typescript
+   * const result = await pgsql.dropDatabase({ database: 'db-name' });
+   * ```
+   */
+  public async dropDatabase({ database }: { database: string; }): Promise<DropDatabaseResponse> {
+    return this.callApi<DropDatabaseResponse>({
+      data: { database },
+      method: 'DELETE',
+      route: 'databases',
+    });
+  }
+
+  /**
+   * List tables
+   * ```typescript
+   * const result = await pgsql.listTables({ database: 'db-name', schema: 'schema-name' });
+   * ```
+   */
+  public async listTables({ database, schema = 'public' }: { database: string; schema?: string; }): Promise<List<string>> {
+    const { rows } = await this.executeQuery<{ table_name: string; }>({
+      query: getListTablesQuery(schema),
+      database,
+    });
+    return makeList<string>(rows.map(x => x.table_name));
+  }
+
+  /**
+   * List schemas
+   * ```typescript
+   * const result = await pgsql.listSchemas({ database: 'db-name' });
+   * ```
+   */
+  public async listSchemas({ database }: { database: string; }): Promise<List<string>> {
+    const { rows } = await this.executeQuery<{ schema_name: string; }>({
+      query: LIST_SCHEMAS_QUERY,
+      database,
+    });
+    return makeList<string>(rows.map(x => x.schema_name));
+  }
+
+  /**
+   * Create schema
+   * ```typescript
+   * const result = await pgsql.createSchema({ database: 'db-name', schema: 'schema-name' });
+   * ```
+   */
+  public async createSchema({ database, schema }: { database: string; schema: string; }): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: createSchemaQuery(schema),
+      database,
+    });
+  }
+
+  /**
+   * Drop schema
+   * ```typescript
+   * const result = await pgsql.dropSchema({ database: 'db-name', schema: 'schema-name' });
+   * ```
+   */
+  public async dropSchema({ database, schema }: { database: string; schema: string; }): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getDropSchemaQuery(schema),
+      database,
+    });
+  }
+
+  /**
+   * Drop table
+   * ```typescript
+   * const result = await pgsql.dropSchema({ database: 'db-name', schema: 'schema-name', table: 'table-name' });
+   * ```
+   */
+  public async dropTable({ database, schema, table }: { database: string; schema: string; table: string; }): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getDropTableQuery(schema, table),
+      database,
+    });
+  }
+
+  /**
+   * Create table
+   * ```typescript
+   * const result = await pgsql.createTable({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   columns: [
+   *    { name: 'col1', type: 'integer' },
+   *    { name: 'col2', type: 'text' }
+   *   ],
+   *   primaryKey: 'col1,col2'
+   * });
+   * ```
+   */
+  public async createTable({ database, schema, table, columns, primaryKey }: CreateTableArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getCreateTableQuery(schema, table, columns, primaryKey),
+      database,
+    });
+  }
+
+  /**
+   * Drop database
+   * ```typescript
+   * const result = await pgsql.addColumns({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   columns: [
+   *    { name: 'col1', type: 'integer' },
+   *    { name: 'col2', type: 'text' }
+   *   ],
+   * });
+   * ```
+   */
+  public async addColumns({ database, schema, table, columns }: AddColumnsArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery<void>({
+      query: getAddColumnsQuery(schema, table, columns),
+      database,
+    });
+  }
+
+  /**
+   * Insert
+   * ```typescript
+   * const result = await pgsql.insert({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   rows: [
+   *    { col1: 'value' }
+   *   ],
+   *   chunkSize: 300,
+   *   context: { progress: 0 } // progress of insert will be set from 0 to 100
+   * });
+   * ```
+   */
+  public async insert({ database, schema, table, rows, chunkSize = 300, context }: InsertArgs): Promise<ExecuteQueryResponse<void>[]> {
+    const res = [];
+
+    const queries = getInsertQueries(schema, table, rows, chunkSize);
+
+    for (const [index, query] of Array.from(queries.entries())) {
+      res.push(await this.executeQuery<void>({
+        query,
+        database,
+      }));
+
+      if (context) {
+        context.progress = Math.min((index + 1) / (rows.length / Math.min(chunkSize, rows.length)), 1) * 100;
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * Select all
+   * ```typescript
+   * const result = await pgsql.selectAll({
+   *   database: 'db-name',
+   *   query: 'select * from table', // must be select only, without limit and offset
+   *   chunkSize: 300,
+   *   offset: 0,
+   *   limit: 0,
+   *   context: { progress: 0, total: 0 } // progress of select will be set from 0 to 100
+   * });
+   * ```
+   */
+  public async selectAll({ database, query, context, chunkSize = 1000, offset = 0, limit }: SelectAllArgs): Promise<List<Row>> {
+    let count: number, rows, result: Row[] = [];
+    if (limit && limit < chunkSize) {
+      chunkSize = limit;
+    }
+
+    if (context) {
+      const { rows } = await this.executeQuery<{ count: number; }>({
+        query: getSelectAllCountQuery(query),
+        database,
+      });
+      count = rows[0].count;
+      context.total = count;
+    }
+
+    do {
+      ({ rows } = await this.executeQuery<Row>({
+        query: getSelectAllQuery(query, offset, chunkSize),
+        database,
+      }));
+      offset += chunkSize;
+      result = result.concat(rows);
+      if (context) {
+        context.progress = Math.min(offset / count! * 100, 100);
+      }
+      if (limit && result.length >= limit) {
+        result = result.slice(0, limit);
+        break;
+      }
+    } while (rows.length);
+
+    return makeList<Row>(result);
+  }
+
+  /**
+   * Get primary keys
+   * ```typescript
+   * const result = await pgsql.getPrimaryKeys({ database: 'db-name', schema: 'schema-name', table: 'table-name' });
+   * ```
+   */
+  public async getPrimaryKeys({ database, schema, table }: { database: string; schema: string; table: string; }): Promise<string> {
+    const { rows } = await this.executeQuery<{ pk: string; }>({
+      database,
+      query: getGetPrimaryKeysQuery(schema, table),
+    });
+    return rows[0].pk;
+  }
+
+  /**
+   * Edit row
+   * ```typescript
+   * const result = await pgsql.editRow({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   key: 'col1',
+   *   value: 'new_value',
+   *   row: { pk: 'pk_val', col1: 'old_value' },
+   *   primaryKeys: 'pk',
+   * });
+   * ```
+   */
+  public async editRow({ database, schema, table, key, value, row, primaryKeys }: EditRowArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery({
+      database,
+      query: getEditRowQuery(schema, table, key, value, row, primaryKeys),
+    });
+  }
+
+  /**
+   * Delete rows
+   * ```typescript
+   * const result = await pgsql.deleteRows({
+   *   database: 'db-name',
+   *   schema: 'schema-name',
+   *   table: 'table-name',
+   *   rows: [
+   *    { pk: 'pk_val', col1: 'value' }
+   *   ],
+   *   primaryKeys: 'pk',
+   * });
+   * ```
+   */
+  public async deleteRows({ database, schema, table, rows, primaryKeys }: DeleteRowsArgs): Promise<ExecuteQueryResponse<void>> {
+    return this.executeQuery({
+      database,
+      query: getDeleteRowsQuery(schema, table, rows, primaryKeys),
+    });
+  }
+
+  /**
+   * Generate create table query for existing table
+   * ```typescript
+   * const result = await pgsql.generateTableSchema({ database: 'db-name', schema: 'schema-name', table: 'table-name' });
+   * ```
+   */
+  public async generateTableSchema({ database, schema, table }: { database: string; schema: string; table: string; }): Promise<string> {
+    const { rows } = await this.executeQuery<{ code: string; }>({
+      database,
+      query: getGenerateTableSchemaQuery(schema, table),
+    });
+
+    return rows[0].code;
+  }
+
+  /**
+   * Get database size
+   * ```typescript
+   * const result = await pgsql.getDBSize();
+   * ```
+   */
+  public async getDBSize(): Promise<GetDBSizeResult> {
+    return await this.callApi<GetDBSizeResult>({
+      method: 'GET',
+      route: 'size',
+    });
+  }
+}

package/src/constants.ts

@@ -0,0 +1,4 @@
+export const SERVICE_KEY = 'pgsql';
+
+export const LIST_SCHEMAS_QUERY = `SELECT schema_name FROM information_schema.schemata
+        where schema_name not in ('pg_catalog', 'information_schema')`;

package/src/index.ts

@@ -0,0 +1,2 @@
+export { Pgsql } from './Pgsql';
+export * from './types';