Владлен Хеллсайт

Вам нужен GraphQL клиент, например urql (urql-vue) или apollo-client (vue-apollo). Если вам нужен один запрос, то можно обойтись обычным fetch, например:

const response = await fetch('https://example.com/graphql', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    operationName: 'fetchAuthor',
    query: 'query fetchAuthor { author { id name } }',
    variables: {},
  }),
});

const data = await response.json();

Невозможно защитить то —что является публичным. Максимум усложнить процесс реверс инжиниринга. Для "защиты" можно использовать обфускацию.

// Это должно быть вне обработчика закэшировано
const myPhrasesList = new Set([
  "test test test test test",
  "test test test test test",
  "test test test test test",
  "test test test test test",
  "test test test test test",
  "test test test test test"
  // ... 1mln length
]);

for (object of wsData) {
    if (!myPhrasesList.has(object.description)) {
       continue;
    }

    this.notification(object, object.description).then()
}

// core.js
const { VK } = require('vk-io');

const vk = new VK({})

module.exports = {
    vk: vk
};

// bot.js
const { vk }  = require('./core.js');

Если упирается в количество запросов на API, вас стоит увеличить apiLimit, попробовать другие режимы
apiMode и apiRequestMode. Дальше вас стоит профилировать свой код что бы понять узкое место.

Client — это одно соединение
Pool — это хранилище соединений, которое по запросу выдаёт свободное соединение, если нет свободных, ждёт пока освободится и выдаёт освободившееся соединение. Соединения с базой это медленно, но если мы заранее поддерживает множество соединений, мы не тратим время на подключение. Так вот Pool берёт заботы о поддержании соединений на себя (обработку закрытия соединений, открытие новых соединений и поддержания соединений с помощью ping).

Если мы говорим о приложении, то правильным выбором будет Pool.

В GraphQL на текущий момент невозможно сделать рекурсивное дерево через вложения, даже если мы будет повторять вложения, она в любом случае будет иметь конечное количество элементов, не говоря уже про размер самого запроса (не ответа). Однако всё не так плохо как может показаться, есть решения для этой проблемы:

1. Возвращать плоский массив элементов, соответственно на клиенте можем собрать дерево.

tasks {
_id
name
status
children {
    _id
    parentId
    name
    status
}

2. Использовать кастомный скаляр, например JSON. Однако в данном случае мы теряем типизацию схемы, в виду того что в скаляре может находится что угодно.
3. Сделать резолвер, который будет фильтровать элементы по ID их родителя. Однако в данном случае, сервер будет получать много запросов, так как в дереве может находится много элементов.

Вытаскивать все рестораны оправдано если вы будете делать PWA и их будет не так много, а потом просто кидать запрос с датой последней синхронизации на поиск изменений. Однако если вы делаете публичное API, то лучше сразу реализовать поиск через аргументы в query, со временем к категориям добавятся сортировки и другие фильтры. Это придётся реализовывать на каждом клиенте отдельно.

Так скажем ваш GraphQL API сейчас работает только с вашей БД, а потом придётся делать скажем REST запросы на чужой API и вот уже вытаскивать все рестораны не так уже выгодно для сервера. Произвести всякие оптимизации будет сложно, так как мы не знаем какие данные нужны клиенту и каждый раз тащим мегабайты ради скажем ресторана с одной категорией, так как человек каждый раз заходит в инкогнито и никакого кэша там снова не будет.

socks-proxy-agent

В чистой Node.js при использование ESM нужно обязательно указывать расширение в связи с следованием спецификации. Если хочется использовать ESM, но не зависеть от чистой Node.js, нужно использовать один из нескольких вариантов:

• TypeScript
  
• Babel
  
• Webpack
  
• Rollup
  
• esm module
  

if (document.title === 'Волга') {
  document.title = 'Ветер';
}

<template>
  <div class="textarea">
    <textarea
      name="card-textarea"
      id=""
      cols="30"
      :rows="rows"
      :placeholder="placeholder"
      :value="value"
      @input="$emit('input', $event.target.value)"
    >

    </textarea>
  </div>
</template>

props: {
    placeholder: {
      type: String,
      default: ""
    },
    rows: {
      type: Number,
      default: 5
    },
    value: {
       type: String
     }
  }

https://github.com/Automattic/node-canvas#registerfont

В библиотеке присутсвует вариант использования клавиатуры с помощью стандартных средств, ссылка на документацию.

cmd.on(/^(?:test)$/i, async (message, bot) => {
    let senderId;

    // Если ответ на сообщение
    if (message.hasReplyMessage) {
        senderId = message.replyMessage.senderId;
    // Если пересланное сообщение
    } else if (message.hasForwards) {
        senderId = message.forwards[0].senderId;
    }
    
    console.log('senderId', senderId)
})

updates.on('new_message', async (message, next) => {
    if (message.hasAttachments('sticker')) {
        await message.send(`kkk`)
    }
})

Можно так:
await sequelize.sync({ alter: true })
Но при обновлении любых индексов он сломается. Вместо этого нужно делать миграции.

Замените MyMutationInput на название своего input объекта.

this.$apollo.mutate({
    mutation: gql`mutation createWrite($input: MyMutationInput!) {
        createWrite(input: $input) {
            write {
                email
            }
        }
    }`,
    variables: {
        input: {
            data: {
                name: data.name,
                email: data.email,
                title: data.title,
                text: data.text,
                doctor: data.doctor,
                date: data.arrive,
                polite: data.polite
            }
        }
    }
})
    .then((result) => {
        console.log(result);
    })
    .catch((error) => {
        console.error(error);
    });

В пуле хранятся соединения, скажем 10 штук. Каждый раз когда мы вызываем pool.query(), мы запрашиваем соединение. Если соединение есть - производится запрос, а потом в пуле обновляется его статус на свободный. Если все соединения уже заняты - ждём пока освободится первый попавшийся. В документации же сказано, что вы должны возвращать соединения в pool (иначе когда подойдёт лимит соединений в пуле, запросы будут ожидаться бесконечно). А pool.end() нужно вызывать когда вам больше не понадобится текущий пулл запросов, например вы его временно создали для другой БД? Пулл сам создаст соединения по необходимости, конечно он не будет выходить за лимиты, иначе бы мы тратили все ресурсы на создание соединений.

app.use(async (req, res, next) => {
    try {
        res.locals.microdata = await getMicrodata();
        
        next();
    } catch (error) {
        next(error);
    }
});