How to use slonik - 10 common examples

): Promise => {
  let booleanExpression = sql.join(
    Object
      .entries(namedAssignmentPayload)
      .map(([key, value]) => {
        // $FlowFixMe
        return sql`${sql.identifier([normalizeIdentifier(key)])} IS DISTINCT FROM ${value}`;
      }),
    sql` OR `,
  );

  if (booleanExpressionValues) {
    booleanExpression = sql.join(
      [
        booleanExpression,
        sql.join(
          Object
            .entries(booleanExpressionValues)
            .map(([key, value]) => {
              // $FlowFixMe
              return sql`${sql.identifier([normalizeIdentifier(key)])} = ${value}`;
            }),
          sql` AND `,
        ),
      ],
      sql` AND `,
    );
  }

  const result = await connection.query(sql`
    UPDATE ${sql.identifier([tableName])}
    SET ${assignmentList(namedAssignmentPayload)}

export default async (
  connection: DatabaseConnectionType,
  tableName: string,
  namedAssignmentPayload: NamedAssignmentPayloadType,

  // eslint-disable-next-line flowtype/no-weak-types
  booleanExpressionValues: Object = null,
): Promise => {
  let booleanExpression = sql.join(
    Object
      .entries(namedAssignmentPayload)
      .map(([key, value]) => {
        // $FlowFixMe
        return sql`${sql.identifier([normalizeIdentifier(key)])} IS DISTINCT FROM ${value}`;
      }),
    sql` OR `,
  );

  if (booleanExpressionValues) {
    booleanExpression = sql.join(
      [
        booleanExpression,
        sql.join(
          Object
            .entries(booleanExpressionValues)

// eslint-disable-next-line flowtype/no-weak-types
  booleanExpressionValues: Object = null,
): Promise => {
  if (booleanExpressionValues) {
    const nonOverlappingNamedAssignmentBindings = pickBy(namedAssignmentPayload, (value, key) => {
      return value !== booleanExpressionValues[key];
    });

    if (Object.keys(nonOverlappingNamedAssignmentBindings).length === 0) {
      return {
        rowCount: 0,
      };
    }

    const booleanExpression = sql.join(
      Object
        .entries(booleanExpressionValues)
        .map(([key, value]) => {
          // $FlowFixMe
          return sql`${sql.identifier([normalizeIdentifier(key)])} = ${value}`;
        }),
      sql` AND `,
    );

    const result = await connection.query(sql`
      UPDATE ${sql.identifier([tableName])}
      SET ${assignmentList(nonOverlappingNamedAssignmentBindings)}
      WHERE ${booleanExpression}
    `);

    return {

// eslint-disable-next-line flowtype/no-weak-types
  booleanExpressionValues: Object = null,
): Promise => {
  let booleanExpression = sql.join(
    Object
      .entries(namedAssignmentPayload)
      .map(([key, value]) => {
        // $FlowFixMe
        return sql`${sql.identifier([normalizeIdentifier(key)])} IS DISTINCT FROM ${value}`;
      }),
    sql` OR `,
  );

  if (booleanExpressionValues) {
    booleanExpression = sql.join(
      [
        booleanExpression,
        sql.join(
          Object
            .entries(booleanExpressionValues)
            .map(([key, value]) => {
              // $FlowFixMe
              return sql`${sql.identifier([normalizeIdentifier(key)])} = ${value}`;
            }),
          sql` AND `,
        ),
      ],
      sql` AND `,
    );
  }

async executed() {
        await createMigrationTable()
        return slonik
          .any(sql`select name, hash from ${sql.identifier([migrationTableName])}`)
          .then(migrations => {
            log('migrations in database:', migrations)
            return migrations
          })
          .then(migrations => migrations.map(r => {
            const name = r.name as string
            /* istanbul ignore if */
            if (r.hash !== hash(name)) {
              log(
                `warning:`,
                `hash in '${migrationTableName}' table didn't match content on disk.`,
                `did you try to change a migration file after it had been run?`,
                {migration: r.name, dbHash: r.hash, diskHash: hash(name)}
              )
            }
            return name

tableName: string,
  ids: $ReadOnlyArray,
  idName: string = 'id',
  identifiers: string,
  resultIsArray: boolean,
): Promise<$ReadOnlyArray> => {
  let rows = [];

  if (ids.length > 0) {
    const idType = typeof ids[0] === 'number' ? 'int4' : 'text';

    // @todo Do not use slonik-sql-tag-raw.

    rows = await connection.any(sql`
      SELECT ${raw(identifiers)}
      FROM ${sql.identifier([tableName])}
      WHERE ${sql.identifier([idName])} = ANY(${sql.array(ids, idType)})
    `);
  }

  const results = [];

  const targetPropertyName = camelCase(idName);

  if (resultIsArray) {
    for (const id of ids) {
      const result = filter(rows, (row) => {
        return row[targetPropertyName] === id;
      });

      results.push(result);
    }

.map(([key, value]) => {
          // $FlowFixMe
          return sql`${sql.identifier([normalizeIdentifier(key)])} = ${value}`;
        }),
      sql` AND `,

sql.join(
          Object
            .entries(booleanExpressionValues)
            .map(([key, value]) => {
              // $FlowFixMe
              return sql`${sql.identifier([normalizeIdentifier(key)])} = ${value}`;
            }),
          sql` AND `,
        ),
      ],
      sql` AND `,
    );
  }

  const result = await connection.query(sql`
    UPDATE ${sql.identifier([tableName])}
    SET ${assignmentList(namedAssignmentPayload)}
    WHERE ${booleanExpression}
  `);

  return {
    rowCount: result.rowCount,
  };
};

connection: DatabaseConnectionType,
  joiningTableName: string,
  targetResourceTableName: string,
  joiningKeyName: string,
  lookupKeyName: string,
  identifiers: string,
  ids: $ReadOnlyArray,
): Promise<$ReadOnlyArray> => {
  let rows = [];

  // @todo Do not use slonik-sql-tag-raw.

  if (ids.length > 0) {
    rows = await connection.any(sql`
      SELECT
        ${sql.identifier(['r1', lookupKeyName + '_id'])} "POSTLOADER_LOOKUP_KEY",
        ${raw(identifiers)}
      FROM ${sql.identifier([joiningTableName])} r1
      INNER JOIN ${sql.identifier([targetResourceTableName])} r2 ON r2.id = ${sql.identifier(['r1', joiningKeyName + '_id'])}
      WHERE ${sql.identifier(['r1', lookupKeyName + '_id'])} = ANY(${sql.array(ids, 'int4')})
    `);
  }

  const results = [];

  for (const id of ids) {
    const result = filter(rows, (row) => {
      return row.POSTLOADER_LOOKUP_KEY === id;
    });

    results.push(result);
  }

lookupKeyName: string,
  identifiers: string,
  ids: $ReadOnlyArray,
): Promise<$ReadOnlyArray> => {
  let rows = [];

  // @todo Do not use slonik-sql-tag-raw.

  if (ids.length > 0) {
    rows = await connection.any(sql`
      SELECT
        ${sql.identifier(['r1', lookupKeyName + '_id'])} "POSTLOADER_LOOKUP_KEY",
        ${raw(identifiers)}
      FROM ${sql.identifier([joiningTableName])} r1
      INNER JOIN ${sql.identifier([targetResourceTableName])} r2 ON r2.id = ${sql.identifier(['r1', joiningKeyName + '_id'])}
      WHERE ${sql.identifier(['r1', lookupKeyName + '_id'])} = ANY(${sql.array(ids, 'int4')})
    `);
  }

  const results = [];

  for (const id of ids) {
    const result = filter(rows, (row) => {
      return row.POSTLOADER_LOOKUP_KEY === id;
    });

    results.push(result);
  }

  return results;
};