Top 10 Examples of "snake-case in functional component" in JavaScript

definition.fields.forEach(field => {
    if (
      field.directives &&
      field.directives.some(directive => directive.name.value === 'index') &&
      // a uniqueness constraint implies an index, so if the @unique directive
      // is present we don't need to add an additional one
      !field.directives.some(directive => directive.name.value === 'unique')
    ) {
      indices.push({table, columns: [snake(field.name.value)]});
    }
  });
  return indices;

export function orderFromOrderArgument(order: string): Order {
  return {
    column: (
      order == null || order === 'ASC' || order === 'DESC'
      ? 'seq'
      : snake(order.replace(/_ASC$|_DESC$/, ''))
    ),
    direction: order && order.match(/DESC$/) ? 'DESC' : 'ASC',
  };
}

constructor(db, scope) {
    this._db = db;
    this._scope = snakeCase(scope);
  }

function checkIfLegalToChain(key) {
  if (this._legalMethods.indexOf(key) === -1) {
    throw new Error(`${key} cannot be called on the current query`)
  }
  if (snakeCase(key) in this._query) {
    throw new Error(`${key} has already been called on this query`)
  }
}

export function columnFromFieldDefintion(definition: FieldDefinition): Column {
  const isId = definition.name.value === 'id';
  return {
    name: snake(definition.name.value),
    type: columnTypeFromGraphQLType(definition.type),
    primaryKey: isId,
    nonNull: isNonNullType(definition.type),
    unique: definition.directives.some(d => d.name.value === 'unique'),
    defaultValue: isId ? 'gen_random_uuid()' : null,
    references: null,
  };
}

async function updateDatabaseSchema(
  localPackage: Object,
  schemaText: string,
  {url}: {url: string}
): Promise<*> {
  let databaseUrl;

  if (url) {
    databaseUrl = url;
  } else {
    const prompt = await get({
      name: 'databaseUrl',
      message: 'what is the url to your database?',
      default: `postgres://localhost/${snake(localPackage.name)}`,
    });
    databaseUrl = prompt.databaseUrl;
  }

  const existingSchema = await readExistingDatabaseSchema(databaseUrl);

  const ast = parse(schemaText);
  const {objectDefinitions, relationships} = databaseInfoFromAST(ast);
  const {db, schema} = generateDatabaseInterface(
    databaseUrl,
    objectDefinitions,
    relationships
  );

  const {sql} = generateDatabaseSchemaMigration(schema, existingSchema);

export function toJson(o: object): object {
  o = {...o};
  for (const key in o) {
    const newKey = snakeCase(key);
    //@ts-ignore
    o[newKey] = o[key] !== null ? serializeToJson(o[key]) : null;
    if (newKey !== key) {
      //@ts-ignore
      delete o[key];
    }
  }
  return o;
}

      .map((key, i) => `${snake(key)} = $${i + initialEscape + 1}`)
      .join(' AND ')

types.forEach(type => {
      let TYPE_SNAKE_CASE = snakeCase(type).toUpperCase();

      if (this.constructor[TYPE_SNAKE_CASE]) {
        return;
      }

      this.constructor[TYPE_SNAKE_CASE] = this[TYPE_SNAKE_CASE] = type;
    });
  }

export function orderFromOrderArgument(defaultOrder: Order, order: ?string): Order {
  if (order == null) {
    return defaultOrder;
  }

  return {
    column: (
      order === 'ASC' || order === 'DESC'
      ? defaultOrder.column
      : snake(order.replace(/_ASC$|_DESC$/, ''))
    ),
    direction: order && order.match(/DESC$/) ? 'DESC' : 'ASC',
  };
}