@or-sdk/pgsql 0.22.5-244.0

package/src/types.ts

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

package/src/utils/createSchemaQuery.ts

@@ -0,0 +1 @@
+export default (schema: string) => `create schema ${schema};`;

package/src/utils/encodeValue.ts

@@ -0,0 +1,11 @@
+import { EncodedValue } from '../types';
+import _ from 'lodash';
+
+function encodeValue(value: unknown): EncodedValue {
+  if (_.isUndefined(value) || value === '' || _.isNull(value)) return 'NULL';
+  if (_.isString(value)) return `'${value.replaceAll('\'', '\'\'')}'`;
+  if (_.isNumber(value) || _.isBoolean(value)) return value;
+  return `'${JSON.stringify(value).replaceAll('\'', '\'\'')}'`;
+}
+
+export default encodeValue;

package/src/utils/extractDatabaseNames.ts

@@ -0,0 +1,7 @@
+import { ListDatabasesResponseItem } from '../types';
+
+function extractDatabaseNames(databaseNameArr: ListDatabasesResponseItem[]): string[] {
+  return databaseNameArr.map(({ name }) => name);
+}
+
+export default extractDatabaseNames;

package/src/utils/getAddColumnsQuery.ts

@@ -0,0 +1,4 @@
+import { TableColumn } from '../types';
+
+export default (schema: string, table: string, columns: TableColumn[]) =>
+  `alter table ${schema}.${table} ${columns.map(x => `add column ${x.name} ${x.type}`).join(', ')};`;

package/src/utils/getCreateTableQuery.ts

@@ -0,0 +1,4 @@
+import { TableColumn } from '../types';
+
+export default (schema: string, table: string, columns: TableColumn[], primaryKey: string) =>
+  `create table ${schema}.${table} (${columns.map(x => `${x.name} ${x.type}`).join(', ')}, primary key (${primaryKey}));`;

package/src/utils/getDeleteRowsQuery.ts

@@ -0,0 +1,10 @@
+import { Row } from '../types';
+import { encodeValue, splitPrimaryKeys } from '../utils';
+
+function getDeleteRowQuery(schema: string, table: string, rows: Row[], primaryKeys: string): string {
+  const pk = splitPrimaryKeys(primaryKeys);
+  return `delete from ${schema}.${table}
+where (${rows.map(row => `${pk.map(primaryKey => `${primaryKey} = ${encodeValue(row[primaryKey])}`).join(' AND ')}`).join(') \nOR (')})`;
+}
+
+export default getDeleteRowQuery;

package/src/utils/getDropSchemaQuery.ts

@@ -0,0 +1 @@
+export default (schema: string) => `drop schema ${schema} cascade;`;

package/src/utils/getDropTableQuery.ts

@@ -0,0 +1 @@
+export default (schema: string, table: string) => `drop table ${schema}.${table};`;

package/src/utils/getEditRowQuery.ts

@@ -0,0 +1,12 @@
+import { encodeValue, splitPrimaryKeys } from '../utils';
+import { Row } from '../types';
+
+function getEditRowQuery(schema: string, table: string, key: string, value: unknown, row: Row, primaryKeys: string): string {
+  value = encodeValue(value);
+  const pk = splitPrimaryKeys(primaryKeys);
+  return `update ${schema}.${table}
+set ${key} = ${value}
+where ${pk.map(primaryKey => `${primaryKey} = ${encodeValue(row[primaryKey])}`).join(' AND ')}`;
+}
+
+export default getEditRowQuery;

package/src/utils/getGenerateTableSchemaQuery.ts

@@ -0,0 +1,17 @@
+export default (schema: string, table: string) => `SELECT 'CREATE TABLE ' || '${schema}.${table}' || ' (' || '\n' || '' ||
+        string_agg(column_list.column_expr, ', ' || '\n' || '') ||
+        '' || ',\n' || 'PRIMARY KEY (' || (SELECT string_agg(a.attname, ', ') AS pk
+    FROM
+        pg_constraint AS c
+        CROSS JOIN LATERAL UNNEST(c.conkey) AS cols(colnum) -- conkey is a list of the columns of the constraint; so we split it into rows so that we can join all column numbers onto their names in pg_attribute
+        INNER JOIN pg_attribute AS a ON a.attrelid = c.conrelid AND cols.colnum = a.attnum
+    WHERE
+        c.contype = 'p' -- p = primary key constraint
+        AND c.conrelid = '${schema}.${table}'::REGCLASS limit 1) || '));'  code
+    FROM (
+      SELECT '    ' || column_name || ' ' || data_type ||
+           coalesce('(' || character_maximum_length || ')', '') ||
+           case when is_nullable = 'YES' then '' else ' NOT NULL' end as column_expr
+      FROM information_schema.columns
+      WHERE table_schema = '${schema}' AND table_name = '${table}'
+      ORDER BY ordinal_position)  column_list;`;

package/src/utils/getGetPrimaryKeysQuery.ts

@@ -0,0 +1,8 @@
+export default (schema: string, table: string) => `SELECT string_agg(a.attname, ', ') AS pk
+FROM
+    pg_constraint AS c
+    CROSS JOIN LATERAL UNNEST(c.conkey) AS cols(colnum) -- conkey is a list of the columns of the constraint; so we split it into rows so that we can join all column numbers onto their names in pg_attribute
+    INNER JOIN pg_attribute AS a ON a.attrelid = c.conrelid AND cols.colnum = a.attnum
+WHERE
+    c.contype = 'p' -- p = primary key constraint
+    AND c.conrelid = '${schema}.${table}'::REGCLASS;`;

package/src/utils/getInsertKeys.ts

@@ -0,0 +1,9 @@
+import { Row } from '../types';
+
+function getInsertKeys(rows: Row[]): string[] {
+  const allKeys = {};
+  rows.forEach(x => Object.assign(allKeys, x));
+  return Object.keys(allKeys);
+}
+
+export default getInsertKeys;

package/src/utils/getInsertQueries.ts

@@ -0,0 +1,18 @@
+import { Row } from '../types';
+import { encodeValue, getInsertKeys } from '../utils';
+import _ from 'lodash';
+
+function getInsertQueries(schema: string, table: string, insertRows: Row[], chunkSize: number): string[] {
+  const rows = _.isArray(insertRows) ? insertRows : [insertRows];
+
+  const keys = getInsertKeys(rows);
+  const stringifyRow = (row: Row) => `${keys.map(key => encodeValue(row[key])).join(', ')}`;
+
+  return _.chain(rows)
+    .chunk(chunkSize)
+    .map((chunk) => `insert into ${schema}.${table} (${keys.join(', ')})
+values (${chunk.map(stringifyRow).join('), (')});`)
+    .value();
+}
+
+export default getInsertQueries;

package/src/utils/getListTablesQuery.ts

@@ -0,0 +1,3 @@
+export default (schema: string) => `SELECT table_name FROM information_schema.tables
+      WHERE table_schema = '${schema}'
+      and table_type = 'BASE TABLE';`;

package/src/utils/getSelectAllCountQuery.ts

@@ -0,0 +1 @@
+export default (query: string) => `select count(*) from (${query}) x`;

package/src/utils/getSelectAllQuery.ts

@@ -0,0 +1 @@
+export default (query: string, offset: number, chunkSize: number) => `${query} offset ${offset} limit ${chunkSize}`;

package/src/utils/index.ts

@@ -0,0 +1,21 @@
+/**
+ * @internal
+ */
+
+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/src/utils/splitPrimaryKeys.ts

@@ -0,0 +1,3 @@
+import _ from 'lodash';
+
+export default (primaryKeys: string) => primaryKeys.split(',').map(x => _.trim(x));

package/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "ES6",
+    "target": "es6",
+    "outDir": "./dist/esm/",
+    "rootDir": "./src"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs/",
+    "rootDir": "./src"
+  }
+}

package/tsconfig.types.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/types/",
+    "rootDir": "./src",
+    "declaration": true,
+    "emitDeclarationOnly": true
+  }
+}