How to use postgraphile-core - 6 common examples

// eslint-disable-next-line no-constant-condition
    while (true) {
      try {
        if (options.watchPg) {
          await watchPostGraphileSchema(pgPool, pgSchemas, options, newSchema => {
            gqlSchema = newSchema;
            _emitter.emit('schemas:changed');
            exportGqlSchema(gqlSchema);
          });
          if (!gqlSchema) {
            throw new Error(
              "Consistency error: watchPostGraphileSchema promises to call the callback before the promise resolves; but this hasn't happened",
            );
          }
        } else {
          gqlSchema = await createPostGraphileSchema(pgPool, pgSchemas, options);
          exportGqlSchema(gqlSchema);
        }
        if (attempts > 0) {
          // tslint:disable-next-line no-console
          console.error(
            `Schema ${
              attempts > 15 ? 'eventually' : attempts > 5 ? 'finally' : 'now'
            } generated successfully`,
          );
        }
        return gqlSchema;
      } catch (error) {
        attempts++;
        const delay = Math.min(100 * Math.pow(attempts, 2), 30000);
        const exitOnFail = !options.retryOnInitFail;
        // If we fail to build our schema, log the error and either exit or retry shortly

async function createGqlSchema(): Promise {
    let attempts = 0;
    // eslint-disable-next-line no-constant-condition
    while (true) {
      try {
        if (options.watchPg) {
          await watchPostGraphileSchema(pgPool, pgSchemas, options, newSchema => {
            gqlSchema = newSchema;
            _emitter.emit('schemas:changed');
            exportGqlSchema(gqlSchema);
          });
          if (!gqlSchema) {
            throw new Error(
              "Consistency error: watchPostGraphileSchema promises to call the callback before the promise resolves; but this hasn't happened",
            );
          }
        } else {
          gqlSchema = await createPostGraphileSchema(pgPool, pgSchemas, options);
          exportGqlSchema(gqlSchema);
        }
        if (attempts > 0) {
          // tslint:disable-next-line no-console
          console.error(

pgClient.query = function(...args: Array): any {
        const [a, b, c] = args;
        // If we understand it (and it uses the promises API)
        if (
          (typeof a === 'string' && !c && (!b || Array.isArray(b))) ||
          (typeof a === 'object' && !b && !c)
        ) {
          if (debugPg.enabled) {
            // Debug just the query text. We don’t want to debug variables because
            // there may be passwords in there.
            debugPg('%s', formatSQLForDebugging(a && a.text ? a.text : a));
          }

          if (pgClient._explainResults) {
            const query = a && a.text ? a.text : a;
            const values = a && a.text ? a.values : b;
            if (query.match(/^\s*(select|insert|update|delete|with)\s/i) && !query.includes(';')) {
              // Explain it
              const explain = `explain ${query}`;
              pgClient._explainResults.push({
                query,
                result: pgClient[$$pgClientOrigQuery]
                  .call(this, explain, values)
                  .then((data: any) => data.rows),
              });
            }
          }

if (typeof setup === 'function') {
      await setup(client);
    } else {
      await client.query(setup);
    }
  }

  const schemaOptions = Object.assign(
    {
      appendPlugins: [require('../index.js')],
      showErrorStack: true,
    },
    options,
  );

  const schema = await createPostGraphileSchema(client, ['p'], schemaOptions);
  return test({
    schema,
    pgClient: client,
  });
});

withPgClient(async client => {
    if (setup) {
      if (typeof setup === "function") {
        await setup(client);
      } else {
        await client.query(setup);
      }
    }
    const schema = await createPostGraphileSchema(client, schemas, options);
    expect(printSchemaOrdered(schema)).toMatchSnapshot();
  });

withPgClient(async (client) => {
    if (setup) {
      if (typeof setup === 'function') {
        await setup(client);
      } else {
        await client.query(setup);
      }
    }
    const schema = await createPostGraphileSchema(client, schemas, options);
    expect(printSchemaOrdered(schema)).toMatchSnapshot();
  });