Download pbf - download do código-fonte pbf

pbf

Outro código-fonte

1.3.2

Baixar

PBF

Biblioteca para serializar e desserializar a sintaxe do filtro PocketBase.

Principais recursos

Suporta todos os operadores e expressões de filtro PocketBase
Suporta Node e navegador
Fornece uma API fluente e (quase) segura para a construção de filtros
Pode ser usado para serializar e desserializar filtros
Suporte TypeScript

Instalação

Você pode instalar facilmente o PBF usando npm ou fio:

npm install pbf

ou

yarn add pbf

Uso

O PBF simplifica o trabalho com a sintaxe do filtro PocketBase. Aqui está um exemplo rápido de como começar:

 import * as pbf from "@nedpals/pbf" ;
import PocketBase from "pocketbase" ;

const pb = new PocketBase ( "<pocketbase url>" ) ;

const result = await pb . collection ( 'example' ) . getList ( 1 , 20 , {
    filter : pbf . stringify ( pbf . and (
        pbf . eq ( 'status' , true ) ,
        pbf . gt ( 'created' , new Date ( "2022-08-01" ) )
    ) ) // status = true && created > "2022-08-01 10:00:00.000Z"
} ) ;

Negando um filtro

Para negar um filtro (por exemplo, igual a diferente e a ou), você pode usar a função not . Isso não nega o valor, mas apenas o operador usado.

 import * as pbf from "@nedpals/pbf" ;

pbf . stringify ( pbf . not ( pbf . eq ( "is_repost" , false ) ) ) // is_repost = false

Geração de filtro condicional

Em alguns casos, você deseja criar um filtro de pesquisa com alguns dos filtros ativados condicionalmente por meio de curto-circuito. Você pode fazer isso adicionando o modificador .maybe antes de chamar os operadores. Isso filtrará quaisquer valores falsos e gerará os filtros apropriados.

 import * as pbf from "@nedpals/pbf" ;

pbf . stringify ( pbf . and . maybe (
    false && pbf . eq ( 'f' , 4 ) ,
    null ,
    pbf . eq ( 'd' , 1 ) ,
    0 ,
    pbf . not ( pbf . eq ( 'e' , 1 ) ) ,
) ) ; // d = 1 && e != 1

Comparando vários valores

Em vez de se repetir escrevendo vários filtros de comparação do mesmo campo, o PBF fornece um atalho fácil através de either dos modificadores.

 import * as pbf from "@nedpals/pbf" ;

// shortcut for pbf.or(pbf.eq("size", "L"), pbf.eq("size", "XL"), pbf.eq("size", "XXL"))
pbf . stringify ( pbf . eq . either ( "size" , [ "L" , "XL" , "XXL" ] ) ) ; // (size = "L" || size = "XL") || size = "XXL"

Desserializar/analisar strings de filtro bruto

O PBF também oferece suporte à análise de sequências de filtros brutos em um formato PBF adequado. Isso é ótimo quando você deseja analisar a consulta de pesquisa de URL ou apenas deseja criar uma experiência de pesquisa semelhante ao PocketBase:

 import * as pbf from "@nedpals/pbf" ;

const result = pbf . parse ( "title = 'example'" ) ; // equivalent to eq("title", "example");

// You can also inject/bind values to placeholders
const resultB = pbf . parse ( "title = {:title}" , { title : "Foo bar" } ) // equivalent of eq("title", "Foo bar")

Formatar

Para tornar possível a serialização/desserialização, o PBF o armazena como um objeto seguindo um formato de árvore de sintaxe para distinguir filtros lógicos, de comparação e em contêineres/parênteses.

 // Taken and modified from the source code for brevity
type FilterValue = number | boolean | string | Date | null ;
type Filter = ComparisonFilter | LogicalFilter | ContainerFilter ;
type Metadata = Record < string , any >

// eg. a = 1
interface ComparisonFilter {
    field : string
    op : Operator
    value : FilterValue
    meta ?: Metadata
}

// eg. a > 1 && b = 2
interface LogicalFilter {
    lhs : Filter
    op : Operator
    rhs : Filter
    meta ?: Metadata
}

// eg. (c = 3)
interface ContainerFilter {
    op : Operator
    filter : Filter
    meta ?: Metadata
}

Isso também torna mais fácil criar filtros manualmente, especialmente ao criar filtros dinâmicos do tipo faceta:

 const filter : Filter = {
    op : "and" ,
    lhs : {
        op : "gte" ,
        field : "shoe_size" ,
        value : 20
    } ,
    rhs : {
        op : "eq" ,
        field : "color" ,
        value : "burgundy"
    }
}

pbf . stringify ( filter ) // shoe_size >= 20 && color = "burgundy"

Diferenças com PocketBase

A partir do PocketBase JS SDK 0.19.0, foi adicionado um novo recurso que permite que filtros sejam construídos de forma semelhante ao PBF. No entanto, existem algumas diferenças importantes entre as duas abordagens.

PocketBase apenas garante que os valores tenham escape adequado e sejam vinculados ao filtro. O usuário ainda é responsável pela construção da sintaxe do filtro, que pode estar sujeita a erros. O PBF, por outro lado, oferece uma solução mais abrangente ao fornecer também uma maneira fácil e extensa de criar filtros de pesquisa complexos sem se preocupar com a sintaxe.

O PBF também foi criado como uma função utilitária única antes que esse recurso fosse adicionado ao PocketBase.