knledg / distraught Goto Github PK

Workerserver errors are getting grouped today. Try exploding the queue_name on periods and use _.startCase to prevent the grouping of all similarly named queues

In a GQL query a developer can request a collection's records and count:

But some PG collections get so large that running a count query is inefficient and it might be beneficial to use the count_estimate query explained here.

We should add a new option to all collections to request the countEstimate.

Merge Requirements

• Add a note in the readme that to use this option, the users will need the count_estimate() function to be created on the Postgres server the GraphQL is interfacing with
• Update builder.js to allow countEstimate as a field
• Update adapter/knex.js such that if countEstimate is a field that was requested, it will call the count_estimate function with the records query as the only parameter passed to it (as a single string)

Example:

select count_estimate('select * from users')

https://www.npmjs.com/package/helmet

For example when I am searching audit logs and I want the user who created the audit log, if no user created it (generated by the server maybe), then it will fetch the first user record.

In create(), if the payload is an empty array or an empty object, throw an error saying Unable to create new database records, expected array of objects or single object, but received ${empty object|empty array}

• Check if the input passed to camelCase is an array, if so map over the array and camelcase each object.
• Remove from gql.helpers namespace
• Apply to snakeCase as well

We need to create a Cache class that ties into Redis.

• In the constructor, link this.redis to a singleton instance of Redis using the environment variable for REDIS_URL. If there is none, fail silently.

• If there is no REDIS_URL in the environment variables throw a TError saying the class cannot method get until a REDIS_URL is added. Create a get function that takes one parameter: key (string). Pull from redis cache with that key, if it fails return null. It should return the value if setting the cache was successful.

• If there is no REDIS_URL in the environment variables throw a TError saying the class cannot method set until a REDIS_URL is added. Create a set function that takes three parameters: key (string), value (any), ttl (number until expiration, check if Redis uses seconds or ms and document that in the function notes). Set a default TTL of 5 minutes if none is set.

• If value is a Fn, execute the Fn.

• If the result of Fn is a promise, await the result.

• If the promise is rejected, throw new TError(Unable to set cache for key ${key}, promise rejected, {promiseErr});

• Create a Fn called getOrSet that takes the same params, as set Fn, but will try a get internally before calling the function to execute fetching the data. Returns promise of a value.

Export from distraught, a singleton instance of the cache Class.

Users can then following get/set pattern:

import {cache} from 'distraught'

async fetchReport() {
    let report = cache.get('report');

    if (! report) {
         report = cache.set('report', await ReportModel.fetch());
         //  or specify a TTL with: report = cache.set('report', await ReportModel.fetch(), 3000);
    }

    return report;
}

or users can utilize the getOrSet fn:

import {cache} from 'distraught';

fetchReport() {
    return cache.getOrSet('report', ReportModel.fetch, 3000); // returns promise
}

Example:

const D = require("distraught");
D.init({
  db: {
    connection1: { connection: process.env.DB_URL },
  },
});

D.init({
  db: {
    connection2: { connection: process.env.DB_URL },
  },
});
// we would get a message about "DB connection connection1 already added"

When we're looping through the each calls in the init section of the code we should make sure the key doesn't exist before we call the respecting addDatabase/addHeretic/addCache calls.

We still need to have addDbConnection available for dynamic database connections

• Add ability to cache results of GQL queries if user specifies cacheKey and cacheTTL on their pgObject

On a pgObject, if the user specifies a cacheKey, the queries will try and check for matches against Redis, before querying PG.

Note: The cacheKey should be letters/numbers (no symbols or spaces), this is actually a prefix to the actual key that is used.

1. If cacheKey exists on the PG object, check that REDIS_URL is in the environment vars. If not, throw a TError saying cacheKey cannot be used without a valid REDIS_URL
2. Check that the cacheKey is letters/numbers only, otherwise throw a TError about invalid cacheKey
3. If there is no cacheTTL, default to 5 minutes
4. Take all user-specified filters and hash them. Then use the get method from the cache singleton instance (#27) to try and return results from cache.
5. If there is no resultset, execute the GQL query, then use the set method from the cache singleton instance to set the cache using the cacheKey-${filterHash} as the full key, the resultset as the value, and the TTL as either the cacheTTL specified on the pgObject or the default of 5 minutes

Need an option in the httpServer to not require sessions.
If something is just and API that uses JWT for auth it shouldn't need a SESSION_SECRET defined.

GraphQL v0.8.* supports NullValue which currently gets stripped from payloads.

This is probably a breaking change for the existing applications

https://www.npmjs.com/package/mock-knex