daniloab

const teamSchema = new Schema({
    name: {
        type: String,
        required: 'name is required',
    },
    tradeName: {
        type: String,
        required: 'trade name is required',
    },
    taxId: {

daniloab

import mongoose from 'mongoose';

const { ObjectId } = mongoose.Schema.Types;
const Schema = mongoose.Schema;

const UserSchema = new Schema({
    name: {
        type: String,
        required: 'name is required',
    },   

daniloab

const playerSchema = new Schema({
    status: {
        type: Number
    },
    name: {
        type: String,
        required: 'name is required',
    },
    lastname: {
        type: String,

daniloab

const graphqlSettingsPerReq = async req => {
    const { user } = await getUser(req.header.authorization);
    
    return {
        graphiql: process.env.NODE_ENV !== 'production',
        schema,
        context: {
            user,
            req,
            dataloaders,

daniloab

export async function getUser (token) {
  if (!token) return { user: null }

  try {
    const decodedToken = jwt.verify(token.substring(4), jwtSecret)

    const user = await User.findOne({ _id: decodedToken.id })

    return {
      user,

daniloab

export default new GraphQLObjectType({
    name: 'Query',
    description: 'The root of all queries',
    fields: () => ({
        me: {
            type: UserType,
            resolve: (root, args, context) => {
                if (!context.user) {
                    return null;
                }

daniloab

  if (isCalculating) {
    const biggestText = getBiggerTextWidth();
    return <span ref={measuredRef}>{biggestText}</span>;
  }

daniloab

  const getBiggerTextWidth = () => {
    return labels.reduce((acc, cur) => {
      if (cur.length >= acc.length) {
        return cur;
      }

      return acc;
    }, '');
  };

daniloab

type Props = {
  labels: string[];
}

const ScaleButtons = ({labels}:Props) => {
  const [isCalculating, setIsCalculating] = useState<boolean>(true);
  const [width, setWidth] = useState<number>(0);

  const measuredRef = useCallback(node => {
    if (node !== null) {

daniloab

  const measuredRef = useCallback(node => {
    if (node !== null) {
      setWidth(node.getBoundingClientRect().width);
    }

    return setIsCalculating(false);
  }, []);