aquameta-datum
Version:
Service layer for the Aquameta database API
176 lines (151 loc) • 17.8 kB
JavaScript
import pg from '@micburks/pg';
const anonConfig = {
user: 'anonymous',
database: 'aquameta',
host: 'localhost',
port: 5432,
max: 4,
idleTimeoutMilliseconds: 30000
};
async function getConnection(config) {
const mergedConfig = { ...anonConfig,
...(config && config.connection || {})
}; // Don't allow user to be overridden
mergedConfig.user = anonConfig.user;
const anonClient = new pg.Client(mergedConfig);
await anonClient.connect();
if (!mergedConfig.sessionId) {
return anonClient;
}
let result;
try {
result = await anonClient.query('select (role_id).name as role_name from endpoint.session where id = $1::uuid', [mergedConfig.sessionId]);
} catch (e) {
await anonClient.end();
throw e;
} // If login fails - continue request as anonymous
if (!result || !result.rows || result.rows.length === 0) {
return anonClient;
} // Release Client - TODO: release back to pool
await anonClient.end(); // Logged in
const userResult = new Result(result.rows[0]);
const user = await userResult.json();
console.log(`connection: logged in as ${user.role_name}`);
const userClient = new pg.Client({ ...mergedConfig,
user: user.role_name
});
await userClient.connect();
return userClient;
}
/**
* Execute query server-side
* @returns {Promise}
*/
export default async function executeConnection(client, query) {
let connection;
try {
connection = await getConnection(client); // let result;
/*
if (query.args && query.args.source) {
const {schemaName, relationName, column, name} = parseSourceUrl(
query.url,
);
const queryResult = await connection.query(
`
select content, mimetype
from (select $1 as content, '$1' as extension from $3.$4 where name='$2') as c
join endpoint.mimetype_extension me on c.extension=me.extension
join endpoint.mimetype m on me.mimetype_id=m.id;
`,
[column, name, schemaName, relationName],
);
result = {...queryResult};
if (result && result.rows && result.rows.length !== 0) {
result.status = 200;
result.message = 'OK';
} else {
result.status = 404;
result.status = 'NOT FOUND';
}
} else {
*/
console.log('trying connection', query.version || client.version, query.method, query.url, JSON.stringify(query.args), JSON.stringify(query.data));
const result = await connection.query('select status, message, response, mimetype ' + 'from endpoint.request($1, $2, $3, $4::json, $5::json)', [query.version || client.version, query.method, query.url, JSON.stringify(query.args), JSON.stringify(query.data)]); //}
// TODO: end connection if userClient, but release if anonClient?
await connection.end();
const res = new Result(result.rows[0]);
if (client.rawResponse) {
return res;
} else {
return res.json().then(r => {
if (r.result) {
return r.result.map(({
row
}) => row);
} else {
return [];
}
});
}
} catch (e) {
// Problem with connecting to database
console.error(`connection: error trying to connect to database`);
console.error(e);
if (connection) {
await connection.end();
}
return null;
}
}
// Mimic response from fetch
class Result {
constructor({
status,
message,
response,
mimetype
}) {
this.status = status;
this.statusText = message;
this.response = response;
this.mimetype = mimetype;
}
async json() {
return JSON.parse(this.response);
}
}
/**
* TODO I want to keep track of how many pools are open and when they connect
* pg-pool has some great events
* pool.on('connect', client => {
* client.count = count++
* })
*/
/**
* TODO in order to do this, I would have to keep track of the open pools,
* instead of doing it with pg.connect()
*
* var pool = new pg.Pool(config)
* pool.connect(callback)
*
* is the same as
*
* pg.connect(config, callback)
*
* and this way, pg will keep track of the pools and not create a new one when
* the same config has been passed in twice
*/
export function parseSourceUrl(pathname) {
const [,, schemaName, relationName, ...rest] = pathname.split('/');
const fileName = rest.join('/');
const lastPeriod = fileName.lastIndexOf('.');
const name = fileName.slice(0, lastPeriod);
const column = fileName.slice(lastPeriod + 1);
return {
schemaName,
relationName,
column,
name
};
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["connection.js"],"names":["pg","anonConfig","user","database","host","port","max","idleTimeoutMilliseconds","getConnection","config","mergedConfig","connection","anonClient","Client","connect","sessionId","result","query","e","end","rows","length","userResult","Result","json","console","log","role_name","userClient","executeConnection","client","version","method","url","JSON","stringify","args","data","res","rawResponse","then","r","map","row","error","constructor","status","message","response","mimetype","statusText","parse","parseSourceUrl","pathname","schemaName","relationName","rest","split","fileName","join","lastPeriod","lastIndexOf","name","slice","column"],"mappings":"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","sourcesContent":["// @flow\n\nimport pg from '@micburks/pg';\nimport type {\n  Client,\n  ConnectionOptions,\n  Executable,\n  QueryResult,\n} from '../types.js';\n\nconst anonConfig: ConnectionOptions = {\n  user: 'anonymous',\n  database: 'aquameta',\n  host: 'localhost',\n  port: 5432,\n  max: 4,\n  idleTimeoutMilliseconds: 30000,\n};\n\ntype PgConnection = {\n  connect: () => Promise<void>,\n  query: (string, Array<any>) => Promise<QueryResult>,\n  end: () => Promise<void>,\n};\n\nasync function getConnection(config?: {\n  [string]: any,\n  connection?: {[string]: any},\n}): Promise<PgConnection> {\n  const mergedConfig = {\n    ...anonConfig,\n    ...((config && config.connection) || {}),\n  };\n  // Don't allow user to be overridden\n  mergedConfig.user = anonConfig.user;\n  const anonClient: PgConnection = new pg.Client(mergedConfig);\n\n  await anonClient.connect();\n\n  if (!mergedConfig.sessionId) {\n    return anonClient;\n  }\n\n  let result;\n  try {\n    result = await anonClient.query(\n      'select (role_id).name as role_name from endpoint.session where id = $1::uuid',\n      [mergedConfig.sessionId],\n    );\n  } catch (e) {\n    await anonClient.end();\n    throw e;\n  }\n\n  // If login fails - continue request as anonymous\n  if (!result || !result.rows || result.rows.length === 0) {\n    return anonClient;\n  }\n\n  // Release Client - TODO: release back to pool\n  await anonClient.end();\n\n  // Logged in\n  const userResult = new Result(result.rows[0]);\n  const user = await userResult.json();\n  console.log(`connection: logged in as ${user.role_name}`);\n  const userClient = new pg.Client({\n    ...mergedConfig,\n    user: user.role_name,\n  });\n  await userClient.connect();\n  return userClient;\n}\n\n/**\n * Execute query server-side\n * @returns {Promise}\n */\nexport default async function executeConnection(\n  client: Client,\n  query: Executable,\n): Promise<QueryResult> {\n  let connection;\n\n  try {\n    connection = await getConnection(client);\n    // let result;\n    /*\n    if (query.args && query.args.source) {\n      const {schemaName, relationName, column, name} = parseSourceUrl(\n        query.url,\n      );\n      const queryResult = await connection.query(\n        `\n        select content, mimetype\n        from (select $1 as content, '$1' as extension from $3.$4 where name='$2') as c\n        join endpoint.mimetype_extension me on c.extension=me.extension\n        join endpoint.mimetype m on me.mimetype_id=m.id;\n      `,\n        [column, name, schemaName, relationName],\n      );\n      result = {...queryResult};\n      if (result && result.rows && result.rows.length !== 0) {\n        result.status = 200;\n        result.message = 'OK';\n      } else {\n        result.status = 404;\n        result.status = 'NOT FOUND';\n      }\n    } else {\n      */\n    console.log(\n      'trying connection',\n      query.version || client.version,\n      query.method,\n      query.url,\n      JSON.stringify(query.args),\n      JSON.stringify(query.data),\n    );\n    const result = await connection.query(\n      'select status, message, response, mimetype ' +\n        'from endpoint.request($1, $2, $3, $4::json, $5::json)',\n      [\n        query.version || client.version,\n        query.method,\n        query.url,\n        JSON.stringify(query.args),\n        JSON.stringify(query.data),\n      ],\n    );\n    //}\n\n    // TODO: end connection if userClient, but release if anonClient?\n    await connection.end();\n\n    const res = new Result(result.rows[0]);\n    if (client.rawResponse) {\n      return res;\n    } else {\n      return res.json().then(r => {\n        if (r.result) {\n          return r.result.map(({row}) => row);\n        } else {\n          return [];\n        }\n      });\n    }\n  } catch (e) {\n    // Problem with connecting to database\n    console.error(`connection: error trying to connect to database`);\n    console.error(e);\n    if (connection) {\n      await connection.end();\n    }\n    return null;\n  }\n}\n\ntype ResultArgs = {\n  status: string,\n  message: string,\n  response: string,\n  mimetype: string,\n};\n// Mimic response from fetch\nclass Result {\n  status: string;\n  statusText: string;\n  response: string;\n  mimetype: string;\n  constructor({status, message, response, mimetype}: ResultArgs) {\n    this.status = status;\n    this.statusText = message;\n    this.response = response;\n    this.mimetype = mimetype;\n  }\n  async json(): Promise<{[string]: any}> {\n    return JSON.parse(this.response);\n  }\n}\n\n/**\n * TODO I want to keep track of how many pools are open and when they connect\n * pg-pool has some great events\n * pool.on('connect', client => {\n *   client.count = count++\n * })\n */\n\n/**\n * TODO in order to do this, I would have to keep track of the open pools,\n * instead of doing it with pg.connect()\n *\n * var pool = new pg.Pool(config)\n * pool.connect(callback)\n *\n * is the same as\n *\n * pg.connect(config, callback)\n *\n * and this way, pg will keep track of the pools and not create a new one when\n * the same config has been passed in twice\n */\n\ntype ParsedSourceUrl = {\n  schemaName: string,\n  relationName: string,\n  column: string,\n  name: string,\n};\n\nexport function parseSourceUrl(pathname: string): ParsedSourceUrl {\n  const [, , schemaName, relationName, ...rest] = pathname.split('/');\n  const fileName = rest.join('/');\n  const lastPeriod = fileName.lastIndexOf('.');\n  const name = fileName.slice(0, lastPeriod);\n  const column = fileName.slice(lastPeriod + 1);\n\n  return {schemaName, relationName, column, name};\n}\n"]}