prostgles-server 4.2.157 → 4.2.159

package/lib/TableConfig/getFutureTableSchema.ts

@@ -1,64 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,326 +0,0 @@
-
-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

@@ -1,13 +0,0 @@
-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;