machineghost's questions

Tenho uma função PostgreSQL:

CREATE OR REPLACE FUNCTION test()
RETURNS some_table
LANGUAGE sql STABLE STRICT SECURITY DEFINER
AS $function$
  SELECT * FROM some_table ;
$function$;

Funciona muito bem e retorna registros some_tablecomo esperado. No entanto, se eu escrever exatamente a mesma consulta, exceto que adiciono um argumento opcional:

CREATE OR REPLACE FUNCTION test(arg VARCHAR DEFAULT NULL)

A função retorna um único resultado de:

null | null | null | null | null | null

Alguém pode explicar o porquê? Pelo que entendi, um argumento não usado ( especialmente um com um DEFAULT) não deveria nem ter impacto na função ou em sua consulta.

O TypeScript gerará um erro ("Uma expressão do tipo 'void' não pode ser testada para trueiness.ts(1345)") com código de depuração válido como:

const getFooPlusTwo = (foo) => console.log(foo) || foo + 2;

Existem vários hacks para contornar isso (adicionando +, ,, etc.), mas eles não funcionam em todas as circunstâncias ... e mais importante, são um trabalho desnecessário e sem nenhum benefício (JS funciona perfeitamente bem sem eles).

A maioria das regras TypeScript pode ser desativada. Existe alguma regra TypeScript (ou ESLint) que eu possa desabilitar para fazer com que o TypeScript não gere esses erros?

Estou usando o Postgraphile, que permite criar funções que usam conjuntos de linhas como argumentos. Por exemplo, tenho uma função que usa um system_versionsconjunto de linhas como parâmetro:

CREATE OR REPLACE FUNCTION public.system_versions_edition_versions(
    system_version system_versions,
    system_title character varying DEFAULT NULL::character varying
 )
 RETURNS SETOF edition_versions
 LANGUAGE sql
 STABLE STRICT SECURITY DEFINER
 AS $function$

        SELECT ev.*
        FROM public.edition_versions ev
        INNER JOIN public.editions e ON ev.edition_id  = e.id
        INNER JOIN public.systems s ON e.system_id  = s.id
        INNER JOIN public.system_versions sv ON s.id  = sv.system_id
        WHERE sv.id = system_version.id
        AND (
          system_title IS NULL
          OR
          sv.title = system_title
        )
  ;
  $function$
;

Normalmente essas funções são chamadas pelo Postgraphile, mas preciso chamar essa manualmente para testar... e não consigo descobrir como fornecer o parâmetro.

Quando eu tento:

SELECT public.system_versions_edition_versions(public.system_versions);

Eu recebo:

ERROR:  missing FROM-clause entry for table "public"
LINE 1: select public.system_versions_edition_versions(public.system...

Mas quando tento SELECT a tabela...

SELECT public.system_versions_edition_versions(SELECT * FROM public.
system_versions);

Eu recebo:

ERROR:  syntax error at or near "select"
LINE 1: select public.system_versions_edition_versions(select * from...

Quando tenho uma função com um parâmetro "row set", alguém pode explicar como forneço esse parâmetro?

HISTÓRIA (sinta-se à vontade para pular para o problema)

Estou tentando desestruturar uma resposta de um Apollo useLazyQuerye depois alterar uma variável. Sem o Typescript, seriam duas linhas simples:

 let [someFunction, { data, loading }] = useLazyQuery(QUERY);
 data = 'whatever'

No entanto, isso ofende o Typescript, porque estou criando todas as variáveis let, embora a maioria não mude. Então, mudei o código para desestruturar a maior parte da resposta como constante, com uma única exceção:

 const stuff = useLazyQuery(QUERY);
 let [_, { data }] = stuff; // get one variable as a non-constant
 const [someFunction, { loading }] = stuff; // get the rest as constants

O problema é que ainda estou recebendo erros/avisos do TypeScript:

O aviso 77:8 '_' recebeu um valor, mas nunca foi usado no-unused-vars

O erro 77:8 '_' nunca é reatribuído. Use 'const' em vez de prefer-const

Claro, _é apenas um espaço reservado para me ajudar a desestruturar data, então não deveria ser reatribuído... mas é necessário na letlinha para fazer a desestruturação funcionar.

PROBLEMA

Eu teria pensado que poderia dizer ao Typescript "não se preocupe _, apenas ignore" adicionando um @ts-ignorecomentário:

 const stuff = useLazyQuery(QUERY);
 // @ts-ignore
 let [_, { data }] = stuff; // get one variable as a non-constant
 const [someFunction, { loading }] = stuff; // get the rest as constants

Mas tudo o que isso faz é adicionar um novo aviso sobre como devo usar @ts-expect-errorem vez de @ts-ignore... isso não elimina o aviso/erro sobre minha _variável.

PERGUNTAS (duas relacionadas)

1. Achei que @ts-ignoreignorei todos os avisos/erros na próxima linha; alguém pode explicar como o Typescript decide quais avisos/erros @ts-ignorerealmente ignoram e quais não?

2. Alguém pode explicar como posso fazer o Typescript parar de reclamar de '_' is never reassigned. Use 'const' insteaderros (de uso @ts-ignoreou qualquer outra coisa)... sem abrir mão de recursos básicos da linguagem, como desestruturação?

Estou tentando escrever um teste de dramaturgo que faça algo após o envio de um formulário. Depois que o formulário é enviado, duas coisas acontecem:

1. uma "gaveta" fecha
2. uma "notificação" aparece

O problema é que a ordem dessas duas coisas pode mudar, apenas devido à aleatoriedade. Então, se eu fizer:

await expectDrawerToClose();
await expectNotification();

ou:

await expectNotification();
await expectDrawerToClose();

... de qualquer forma, às vezes será errado. Existe alguma maneira no Playwright de fazer de alguma forma:

await expectTwoThingsToHappenInAnyOrder(
    expectDrawerToClose(),
    expectNotification()
);

Eu sei que posso encadear localizadores com or, mas isso não é a mesma coisa: não quero dizer "Vou ver uma dessas duas coisas acontecer" ... quero dizer "Vou ver ambos acontecem; eu simplesmente não me importo com a ordem."

Isso parece tão incrivelmente básico que tenho vergonha de perguntar ao Stack Overflow, mas juro que tentei pesquisar no Google e ver os documentos do Cypress primeiro!

Pergunta simples: Cypress tem asserções ( cy.should) e uma maneira de pausar o executor de teste ( cy.pause) ... existe alguma maneira de conectar os dois, de modo que, se shouldfalhar, o executor de teste faça uma pausa?

Eu sei que posso fazer:

cy.should(whatever)
  .pause();

... mas isso sempre faz uma pausa . Eu só quero fazer uma pausa se falhar should.

PS Você pode pensar:

try {
  cy.should(whatever)
} catch (err) {
  cy.pause();
}

funcionaria ... mas não funciona, porque (como tudo no Cypress) o lançamento real do erro não acontece na shouldlinha ... acontece mais tarde (quando não pode ser detectado).

Da mesma forma, tentei fazer:

cy.on('uncaught:exception', () => {
  cy.pause();
});
cy.should(whatever);

Mas não funciona, provavelmente porque quando o erro é detectado usando cy.on, já é tarde demais para fazer uma pausa.