prostgles-server 4.2.159 → 4.2.161

package/lib/TableConfig/getFutureTableSchema.ts

@@ -0,0 +1,64 @@
+import { asName } from "prostgles-types";
+import { pgp } from "../DboBuilder/DboBuilder";
+import { DB } from "../Prostgles";
+import { ColumnMinimalInfo, getTableColumns } from "./getColumnDefinitionQuery";
+import { ColConstraint, ConstraintDef, getColConstraints } from "./getConstraintDefinitionQueries";
+
+type Args = {
+  db: DB, 
+  columnDefs: string[]; 
+  tableName: string;
+  constraintDefs?: ConstraintDef[];
+};
+ 
+export const getFutureTableSchema = async ({ columnDefs, tableName, constraintDefs = [], db }: Args): Promise<{
+  constraints: ColConstraint[];
+  cols: ColumnMinimalInfo[];
+}> => { 
+  const { TransactionMode, isolationLevel } = pgp.txMode;
+   
+  let constraints: ColConstraint[] = [];
+  let cols: ColumnMinimalInfo[] = [];
+  const ROLLBACK = "Rollback";
+  try {
+    const txMode = new TransactionMode({
+      tiLevel: isolationLevel.serializable
+    });
+    await db.tx({ mode: txMode }, async t => {
+
+      /** To prevent deadlocks we use a random table name -> Not feasible because named constraints cannot be recreated without dropping the existing ones from actual table */
+      // const tableEsc = asName(tableName.slice(0, 12) + (await t.oneOrNone(`SELECT md5(now()::text) as md5`)).md5); 
+      
+      const tableEsc = asName(tableName);
+
+      const consQueries = constraintDefs.map(c => 
+        `ALTER TABLE ${tableEsc} ADD ${c.name? ` CONSTRAINT ${asName(c.name)}` : ""} ${c.content};`
+      ).join("\n");
+
+      const query = `
+        DROP TABLE IF EXISTS ${tableEsc} CASCADE;
+        CREATE TABLE ${tableEsc} (
+          ${columnDefs.join(",\n")}
+        );
+        ${consQueries}
+      `;
+
+      await t.any(query);
+
+      constraints = await getColConstraints({ db: t, table: tableName });
+      cols = await getTableColumns({ db: t, table: tableName });
+ 
+      /** Rollback */
+      return Promise.reject(new Error(ROLLBACK));
+    });
+
+  } catch(e: any){
+    if(e instanceof Error && e.message === ROLLBACK) {
+      // Ignore
+    } else {
+      throw e;
+    }
+  }
+  
+  return { cols, constraints };
+}

package/lib/TableConfig/getPGIndexes.ts

@@ -0,0 +1,53 @@
+import { DB } from "../Prostgles";
+
+type PGIndex = {
+  schemaname: string;
+  indexname: string;
+  indexdef: string;
+  escaped_identifier: string;
+  type: string;
+  owner: string;
+  tablename: string;
+  persistence: string;
+  access_method: string;
+  size: string;
+  description: string | null;
+};
+export const getPGIndexes = async (db: DB, tableName: string, schema: string): Promise<PGIndex[]> => {
+
+  const indexQuery = `
+    SELECT n.nspname as schemaname,
+      c.relname as indexname,
+      pg_get_indexdef(c.oid) as indexdef,
+      format('%I', c.relname) as escaped_identifier,
+      CASE c.relkind WHEN 'r' 
+        THEN 'table' WHEN 'v' 
+        THEN 'view' WHEN 'm' 
+        THEN 'materialized view' 
+        WHEN 'i' THEN 'index' 
+        WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' 
+        WHEN 't' THEN 'TOAST table' WHEN 'f' THEN 'foreign table' 
+        WHEN 'p' THEN 'partitioned table' WHEN 'I' THEN 'partitioned index' END as "type",
+      pg_catalog.pg_get_userbyid(c.relowner) as "owner",
+      c2.relname as tablename,
+      CASE c.relpersistence WHEN 'p' THEN 'permanent' WHEN 't' THEN 'temporary' 
+      WHEN 'u' THEN 'unlogged' END as "persistence",
+      am.amname as "access_method",
+      pg_catalog.pg_size_pretty(pg_catalog.pg_table_size(c.oid)) as "size",
+      pg_catalog.obj_description(c.oid, 'pg_class') as "description"
+    FROM pg_catalog.pg_class c
+        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam
+        LEFT JOIN pg_catalog.pg_index i ON i.indexrelid = c.oid
+        LEFT JOIN pg_catalog.pg_class c2 ON i.indrelid = c2.oid
+    WHERE c.relkind IN ('i','I','')
+          AND n.nspname <> 'pg_catalog'
+          AND n.nspname !~ '^pg_toast'
+          AND n.nspname <> 'information_schema'
+      AND pg_catalog.pg_table_is_visible(c.oid)
+    AND c2.relname = \${tableName}
+    AND n.nspname = \${schema}
+    ORDER BY 1,2;
+    `
+  return db.any(indexQuery, { tableName, schema });
+};

package/lib/TableConfig/getTableColumnQueries.ts

@@ -0,0 +1,129 @@
+import { getKeys, asName as _asName, isObject, asName } from "prostgles-types";
+import { DB, DBHandlerServer } from "../Prostgles";
+import { validate_jsonb_schema_sql } from "../JSONBValidation/validate_jsonb_schema_sql";
+import { getColumnDefinitionQuery, getTableColumns } from "./getColumnDefinitionQuery";
+import { TableConfig } from "./TableConfig"; 
+import { getFutureTableSchema } from "./getFutureTableSchema";
+
+type Args = {
+  db: DB;
+  tableConf: TableConfig[string];
+  tableName: string;
+  tableHandler: DBHandlerServer[string] | undefined;
+}
+
+export const getTableColumnQueries = async ({ db, tableConf, tableName, tableHandler }: Args): Promise<undefined | {
+  columnDefs: string[];
+  newColumnDefs: string[];
+  fullQuery: string;
+  isCreate: boolean;
+}> => {
+
+  let newColumnDefs: string[] = [];
+  const droppedColNames: string[] = [];
+  const alteredColQueries: string[] = [];
+  let fullQuery = "";
+  let isCreate = false;
+
+  if ("columns" in tableConf && tableConf.columns) {
+  
+    const hasJSONBValidation = getKeys(tableConf.columns).some(c => {
+      const cConf = tableConf.columns?.[c];
+      return cConf && isObject(cConf) && (cConf.jsonbSchema || cConf.jsonbSchemaType)
+    });
+
+    /** Must install validation function */
+    if(hasJSONBValidation){
+      try {
+        await db.any(validate_jsonb_schema_sql);
+      } catch(err: any){
+        console.error("Could not install the jsonb validation function due to error: ", err);
+        throw err;
+      }
+    }
+
+    const columns = getKeys(tableConf.columns).filter(c => {
+      const colDef = tableConf.columns![c]!;
+      /** Exclude NamedJoinColumn  */
+      return typeof colDef === "string" || !("joinDef" in colDef)
+    }) as string[];
+
+    const colDefs: { name: string; def: string }[] = [];
+    
+    for (const colName of columns) {
+      const colConf = tableConf.columns![colName]!;
+
+      /* Get column definition */
+      const colDef = await getColumnDefinitionQuery({ colConf, column: colName, db, table: tableName });
+      if(colDef){
+        colDefs.push({ name: colName, def: colDef});
+      }
+    }
+    const columnDefs = colDefs.map(c => c.def);
+
+    if(!colDefs.length){
+      return undefined;
+    }
+
+
+    const ALTERQ = `ALTER TABLE ${asName(tableName)}`;
+    if (!tableHandler) {
+      newColumnDefs.push(...colDefs.map(c => c.def));
+
+    } else if (tableHandler) {
+      const currCols = await getTableColumns({ db, table: tableName });
+
+      /** Add new columns */
+      newColumnDefs = colDefs.filter(nc => !tableHandler.columns?.some(c => nc.name === c.name)).map(c => c.def);
+      
+      /** Altered/Dropped columns */
+      const { cols: futureCols } = await getFutureTableSchema({ tableName, columnDefs, constraintDefs: [], db });
+      currCols.forEach(c => {
+        const newCol = futureCols.find(nc => nc.column_name === c.column_name);
+        if(!newCol){
+          droppedColNames.push(c.column_name);
+        } else if(newCol.nullable !== c.nullable){
+          alteredColQueries.push(`${ALTERQ} ALTER COLUMN ${asName(c.column_name)} ${newCol.nullable? "SET" : "DROP"} NOT NULL;`)
+        } else if(newCol.udt_name !== c.udt_name){
+          alteredColQueries.push(`${ALTERQ} ALTER COLUMN ${asName(c.column_name)} TYPE ${newCol.udt_name} USING ${asName(c.column_name)}::${newCol.udt_name};`)
+        } else if(newCol.column_default !== c.column_default){
+          const colConfig = colDefs.find(cd => cd.name === c.column_name);
+          if(["serial", "bigserial"].some(t => colConfig?.def.toLowerCase().includes(` ${t}`)) && c.column_default?.toLowerCase().includes("nextval")){
+            /** Ignore SERIAL/BIGSERIAL <> nextval mismatch */
+          } else {
+            alteredColQueries.push(`${ALTERQ} ALTER COLUMN ${asName(c.column_name)} ${newCol.column_default === null? "DROP DEFAULT" : `SET DEFAULT ${newCol.column_default}`};`)
+          }
+        }
+      });
+    }
+
+    if (!tableHandler || tableConf.dropIfExists || tableConf.dropIfExistsCascade) {
+      isCreate = true;
+      const DROPQ = `DROP TABLE IF EXISTS ${asName(tableName)}`;
+      fullQuery = ([
+        ...(tableConf.dropIfExists? [`${DROPQ};`] : tableConf.dropIfExistsCascade? [`${DROPQ} CASCADE;`] : []),
+        `CREATE TABLE ${asName(tableName)} (`,
+          columnDefs.join(", \n"),
+        `);`
+      ].join("\n"));
+
+    } else {
+      fullQuery = [
+        ...droppedColNames.map(c => `${ALTERQ} DROP COLUMN ${asName(c)};`),
+        ...newColumnDefs.map(c => `${ALTERQ} ADD COLUMN ${c};`),
+        ...alteredColQueries,
+      ].join("\n");
+    }
+
+    return {
+      fullQuery,
+      columnDefs,
+      isCreate,
+      newColumnDefs,
+    }
+  } else {
+    return undefined;
+  }
+
+
+}

package/lib/TableConfig/initTableConfig.ts

@@ -0,0 +1,326 @@
+
+import { asName as _asName } from "prostgles-types";
+import { PubSubManager, asValue, log } from "../PubSubManager/PubSubManager";
+import TableConfigurator from "./TableConfig";
+import { getColConstraints, getConstraintDefinitionQueries } from "./getConstraintDefinitionQueries";
+import { getFutureTableSchema } from "./getFutureTableSchema";
+import { getTableColumnQueries } from "./getTableColumnQueries";
+import { getPGIndexes } from "./getPGIndexes";
+
+export const initTableConfig = async function (this: TableConfigurator<any>) {
+
+  let changedSchema = false;
+  const failedQueries: { query: string; error: any }[] = [];
+  this.initialising = true;
+  const queryHistory: string[] = [];
+  let queries: string[] = [];
+  const makeQuery = (q: string[]) => q.filter(v => v.trim().length).map(v => v.trim().endsWith(";") ? v : `${v};`).join("\n");
+  const runQueries = async (_queries = queries) => {
+    let q = makeQuery(queries);
+    if (!_queries.some(q => q.trim().length)) {
+      return 0;
+    }
+    q = `/* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */ \n\n` + q;
+    queryHistory.push(q);
+    this.prostgles.opts.onLog?.({ type: "debug", command: "TableConfig.runQueries.start", data: { q }, duration: -1 });
+    const now = Date.now();
+    await this.db.multi(q).catch(err => {
+      log({ err, q });
+      failedQueries.push({ query: q, error: err });
+      return Promise.reject(err);
+    });
+    this.prostgles.opts.onLog?.({ type: "debug", command: "TableConfig.runQueries.end", duration: Date.now() - now, data: { q } });
+    changedSchema = true;
+    _queries = [];
+    queries = [];
+    return 1;
+  }
+
+  if (!this.prostgles.pgp) {
+    throw "pgp missing";
+  }
+
+  const MAX_IDENTIFIER_LENGTH = +(await this.db.one("SHOW max_identifier_length;") as any).max_identifier_length;
+  if (!Number.isFinite(MAX_IDENTIFIER_LENGTH)) throw `Could not obtain a valid max_identifier_length`;
+  const asName = (v: string) => {
+    if (v.length > MAX_IDENTIFIER_LENGTH - 1) {
+      throw `The identifier name provided (${v}) is longer than the allowed limit (max_identifier_length - 1 = ${MAX_IDENTIFIER_LENGTH - 1} characters )\n Longest allowed: ${_asName(v.slice(0, MAX_IDENTIFIER_LENGTH - 1))} `
+    }
+
+    return _asName(v);
+  }
+
+  let migrations: { version: number; table: string; } | undefined;
+  if (this.prostgles.opts.tableConfigMigrations) {
+    const { onMigrate, version, versionTableName = "schema_version" } = this.prostgles.opts.tableConfigMigrations;
+    await this.db.any(`
+        /* ${PubSubManager.EXCLUDE_QUERY_FROM_SCHEMA_WATCH_ID} */
+        CREATE TABLE IF NOT EXISTS ${asName(versionTableName)}(id NUMERIC PRIMARY KEY, table_config JSONB NOT NULL)
+      `);
+    migrations = { version, table: versionTableName };
+    let latestVersion: number | undefined;
+    try {
+      latestVersion = Number((await this.db.oneOrNone(`SELECT MAX(id) as v FROM ${asName(versionTableName)}`)).v);
+    } catch (e) {
+
+    }
+
+    if (latestVersion === version) {
+      const isLatest = (await this.db.oneOrNone(`SELECT table_config = \${table_config} as v FROM ${asName(versionTableName)} WHERE id = \${version}`, { version, table_config: this.config })).v;
+      if (isLatest) {
+        return;
+      }
+    }
+    if (!latestVersion || latestVersion < version) {
+      await onMigrate({ db: this.db, oldVersion: latestVersion, getConstraints: (table, col, types) => getColConstraints({ db: this.db, table, column: col, types }) })
+    }
+  }
+
+  /* Create lookup tables */
+  for (const [tableNameRaw, tableConf] of Object.entries(this.config)) {
+    const tableName = asName(tableNameRaw);
+
+    if ("isLookupTable" in tableConf && Object.keys(tableConf.isLookupTable?.values).length) {
+      const { dropIfExists = false, dropIfExistsCascade = false } = tableConf;
+      const isDropped = dropIfExists || dropIfExistsCascade;
+
+      if (dropIfExistsCascade) {
+        queries.push(`DROP TABLE IF EXISTS ${tableName} CASCADE;`);
+      } else if (dropIfExists) {
+        queries.push(`DROP TABLE IF EXISTS ${tableName};`);
+      }
+
+      const rows = Object.entries(tableConf.isLookupTable?.values).map(([id, otherColumns])=> ({ id, ...otherColumns }));
+      const lookupTableHandler = this.dbo?.[tableNameRaw];
+      const columnNames = Object.keys(rows[0]!).filter(k => k !== "id");
+      if (isDropped || !lookupTableHandler) {
+        queries.push(
+          `CREATE TABLE IF NOT EXISTS ${tableName} (
+            id  TEXT PRIMARY KEY
+            ${columnNames.length ? (", " + columnNames.map(k => asName(k) + " TEXT ").join(", ")) : ""}
+          );`
+        );
+      }
+      if(rows.length){
+        const existingValues: { id: any }[] = !lookupTableHandler? [] : await this.db.any(`SELECT id FROM ${tableName} WHERE id IN (${rows.map(r => asValue(r.id)).join(", ")});`);
+        rows
+        .filter(r => !existingValues.some(ev => ev.id === r.id))
+        .map(row => {
+          const allColumns =  ["id", ...columnNames]
+          const values = allColumns.map(key => (row as any)[key]);
+          queries.push(this.prostgles.pgp!.as.format(`INSERT INTO ${tableName}  (${allColumns.map(t => asName(t)).join(", ")})  ` + " VALUES (${values:csv});", { values }))
+        });
+      }
+    }
+  }
+
+  if (queries.length) {
+    await runQueries(queries);
+    await this.prostgles.refreshDBO();
+  }
+
+  /* Create/Alter columns */
+  for (const [tableName, tableConf] of Object.entries(this.config)) {
+    const tableHandler = this.dbo[tableName];
+
+    const ALTER_TABLE_Q = `ALTER TABLE ${asName(tableName)}`;
+
+    /* isLookupTable table has already been created */
+    const coldef = "isLookupTable" in tableConf? undefined : await getTableColumnQueries({ db: this.db, tableConf, tableHandler, tableName });
+
+    if (coldef) {
+      queries.push(coldef.fullQuery);
+    }
+
+    /** CONSTRAINTS */
+    const constraintDefs = getConstraintDefinitionQueries({ tableName, tableConf });
+    if (coldef?.isCreate) {
+      queries.push(...constraintDefs?.map(c => c.alterQuery) ?? []);
+
+    } else if (coldef) {
+      const fullSchema = await getFutureTableSchema({ db: this.db, tableName, columnDefs: coldef.columnDefs, constraintDefs });
+      const futureCons = fullSchema.constraints.map(nc => ({
+        ...nc,
+        isNamed: constraintDefs?.some(c => c.name === nc.name)
+      }));
+
+      /** Run this first to ensure any dropped cols drop their constraints as well */
+      await runQueries(queries);
+      const currCons = await getColConstraints({ db: this.db, table: tableName });
+
+      /** Drop removed/modified */
+      currCons.forEach(c => {
+        if (!futureCons.some(nc => nc.definition === c.definition && (!nc.isNamed || nc.name === c.name))) {
+          queries.push(`${ALTER_TABLE_Q} DROP CONSTRAINT ${asName(c.name)};`)
+        }
+      });
+
+      /** Add missing named constraints */
+      constraintDefs?.forEach(c => {
+        if (c.name && !currCons.some(cc => cc.name === c.name)) {
+          const fc = futureCons.find(nc => nc.name === c.name);
+          if (fc) {
+            queries.push(`${ALTER_TABLE_Q} ADD CONSTRAINT ${asName(c.name)} ${c.content};`);
+          }
+        }
+      });
+
+      /** Add remaining missing constraints */
+      futureCons
+        .filter(nc =>
+          !currCons.some(c => c.definition === nc.definition)
+        )
+        .forEach(c => {
+          queries.push(`${ALTER_TABLE_Q} ADD ${c.definition};`)
+        });
+    }
+
+
+    if ("indexes" in tableConf && tableConf.indexes) {
+      /*
+          CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name [ USING method ]
+            ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )
+            [ INCLUDE ( column_name [, ...] ) ]
+            [ NULLS [ NOT ] DISTINCT ]
+            [ WITH ( storage_parameter [= value] [, ... ] ) ]
+            [ TABLESPACE tablespace_name ]
+            [ WHERE predicate ]
+      */
+      const currIndexes = await getPGIndexes(this.db, tableName, "public");
+      Object.entries(tableConf.indexes).forEach(([
+        indexName,
+        {
+          columns,
+          concurrently,
+          replace,
+          unique,
+          using,
+          where = ""
+        }
+      ]) => {
+
+        if (replace || typeof replace !== "boolean" && tableConf.replaceUniqueIndexes) {
+          queries.push(`DROP INDEX IF EXISTS ${asName(indexName)};`);
+        }
+        if (!currIndexes.some(idx => idx.indexname === indexName)) {
+          queries.push([
+            "CREATE",
+            unique && "UNIQUE",
+            concurrently && "CONCURRENTLY",
+            `INDEX ${asName(indexName)} ON ${asName(tableName)}`,
+            using && ("USING " + using),
+            `(${columns})`,
+            where && `WHERE ${where}`
+          ].filter(v => v).join(" ") + ";");
+        }
+      });
+    }
+
+    const { triggers, dropIfExists, dropIfExistsCascade } = tableConf;
+    if (triggers) {
+      const isDropped = dropIfExists || dropIfExistsCascade;
+
+      const existingTriggers = await this.dbo.sql!(`
+            SELECT event_object_table
+              ,trigger_name
+            FROM  information_schema.triggers
+            WHERE event_object_table = \${tableName}
+            ORDER BY event_object_table
+          `,
+        { tableName },
+        { returnType: "rows" }
+      ) as { trigger_name: string }[];
+
+      // const existingTriggerFuncs = await this.dbo.sql!(`
+      //   SELECT p.oid,proname,prosrc,u.usename
+      //   FROM  pg_proc p  
+      //   JOIN  pg_user u ON u.usesysid = p.proowner  
+      //   WHERE prorettype = 2279;
+      // `, {}, { returnType: "rows" }) as { proname: string }[];
+
+      Object.entries(triggers).forEach(([triggerFuncName, trigger]) => {
+
+        const funcNameParsed = asName(triggerFuncName);
+
+        let addedFunc = false;
+        const addFuncDef = () => {
+          if (addedFunc) return;
+          addedFunc = true;
+          queries.push(`
+              CREATE OR REPLACE FUNCTION ${funcNameParsed}()
+                RETURNS trigger
+                LANGUAGE plpgsql
+              AS
+              $$
+  
+              ${trigger.query}
+              
+              $$;
+            `);
+        }
+
+        trigger.actions.forEach(action => {
+          const triggerActionName = triggerFuncName + "_" + action;
+
+          const triggerActionNameParsed = asName(triggerActionName)
+          if (isDropped) {
+            queries.push(`DROP TRIGGER IF EXISTS ${triggerActionNameParsed} ON ${tableName};`)
+          }
+
+          if (isDropped || !existingTriggers.some(t => t.trigger_name === triggerActionName)) {
+            addFuncDef();
+            const newTableName = action !== "delete" ? "NEW TABLE AS new_table" : "";
+            const oldTableName = action !== "insert" ? "OLD TABLE AS old_table" : "";
+            queries.push(`
+                CREATE TRIGGER ${triggerActionNameParsed}
+                ${trigger.type} ${action} ON ${tableName}
+                REFERENCING ${newTableName} ${oldTableName}
+                FOR EACH ${trigger.forEach}
+                EXECUTE PROCEDURE ${funcNameParsed}();
+              `);
+          }
+        })
+      })
+    }
+  }
+
+  if (queries.length) {
+    const q = makeQuery(queries);
+
+    try {
+      await runQueries(queries);
+    } catch (err: any) {
+      this.initialising = false;
+
+      console.error("TableConfig error: ", err);
+      if (err.position) {
+        const pos = +err.position;
+        if (Number.isInteger(pos)) {
+          return Promise.reject(err.toString() + "\n At:" + q.slice(pos - 50, pos + 50));
+        }
+      }
+
+      return Promise.reject(err);
+    }
+  }
+
+  if (migrations) {
+    await this.db.any(`INSERT INTO ${migrations.table}(id, table_config) VALUES (${asValue(migrations.version)}, ${asValue(this.config)}) ON CONFLICT DO NOTHING;`)
+  }
+  this.initialising = false;
+  if (changedSchema && !failedQueries.length) {
+    if (!this.prevInitQueryHistory) {
+      this.prevInitQueryHistory = queryHistory;
+    } else if (this.prevInitQueryHistory.join() !== queryHistory.join()) {
+      this.prostgles.init(this.prostgles.opts.onReady as any, { type: "TableConfig" });
+    } else {
+      console.error("TableConfig loop bug", queryHistory)
+    }
+  }
+  if (failedQueries.length) {
+    console.error("Table config failed queries: ", failedQueries)
+  }
+
+  await this.prostgles.refreshDBO();
+  this.setTableOnMounts();
+}

package/lib/index.ts

@@ -0,0 +1,13 @@
+import { SessionUser } from "./Auth/AuthTypes";
+import { Prostgles } from "./Prostgles";
+import { ProstglesInitOptions } from "./ProstglesTypes";
+
+import { testDboTypes } from "./typeTests/dboTypeCheck";
+testDboTypes();
+
+function prostgles<S = void, SUser extends SessionUser = SessionUser>(params: ProstglesInitOptions<S, SUser>){
+
+    const prgl = new Prostgles(params as any);
+    return prgl.init(params.onReady as any, { type: "init" });
+}
+export = prostgles;