hyper durable

Hiperdurável

HyperDurable é uma classe base para objetos duráveis ​​para permitir acesso natural, semelhante a um objeto, ao armazenamento persistente subjacente a partir de stubs de objetos duráveis. O HyperDurable abstrai completamente a API de busca de objetos duráveis, melhorando a legibilidade do código nas camadas de lógica de negócios.

• Abstrai a API de busca de objetos duráveis
• Persiste automaticamente dados sujos
• Construído com TypeScript
• Conjunto de testes abrangente

Instalação

Com Fio:

yarn add @ticketbridge/hyper-durable

Com NPM:

npm i @ticketbridge/hyper-durable

Uso

Escreva sua classe de objeto durável estendendo a classe base HyperDurable . No construtor, passe o state e env para HyperDurable via super() . HyperDurable carregará todos os dados persistidos anteriormente na memória dentro de seu fetch , portanto, quaisquer propriedades definidas no construtor após chamar super() serão substituídas por quaisquer dados persistidos anteriormente.

Dentro do seu objeto durável, acesse propriedades e métodos na memória usando this . Não há necessidade de se preocupar com persistência – dados sujos persistem no final de cada solicitação de busca.

 // RubberDuck.js
import { HyperDurable } from '@ticketbridge/hyper-durable' ;

export class RubberDuck extends HyperDurable {
  constructor ( state , env ) {
    // Pass state and env to HyperDurable
    super ( state , env ) ;

    // Anything set here will be overriden by previously persisted data, if any exists
    // Therefore, you can safely set default values here
    this . name = 'New Duck' ;
    this . favoriteFoods = [ ] ;
  }

  addFavoriteFood ( food ) {
    this . favoriteFoods . push ( food ) ;
  }

  sayHello ( ) {
    return `Hello world, my name is ${ this . name } , and I have ${ this . favoriteFoods . length } favorite foods.` ;
  }
}

Em seu trabalhador, primeiro faça proxy de seus namespaces de objetos duráveis ​​com proxyHyperDurables . A obtenção de um stub permanece inalterada: gere seu id com seu método preferido da API de namespace (ou seja, newUniqueId , idFromName , idFromString ) e use get para construir um stub de objeto.

Cada operação de stub deve ser await , já que todas elas usam a API fetch nos bastidores. As propriedades podem ser lidas diretamente do stub. As propriedades podem ser definidas com seus setters gerados automaticamente (no formato set + PropName ). Os métodos podem ser chamados diretamente do stub.

 // worker.js
import { proxyHyperDurables } from '@ticketbridge/hyper-durable' ;
import { RubberDuck } from './RubberDuck' ;

// Export the DO class
export { RubberDuck } ;

export default {
  async fetch ( request , env ) {
    // Proxy the namespace
    const { RUBBERDUCK } = proxyHyperDurables ( env , {
      // BINDINGNAME: DurableObjectClass
      RUBBERDUCK : RubberDuck
    } ) ;

    // Obtain a stub
    const id = RUBBERDUCK . idFromName ( 'firstDuck' ) ;
    const stub = RUBBERDUCK . get ( id ) ;

    // Await properties
    const name = await stub . name ; // 'New Duck'

    // Await setters
    const newName = await stub . setName ( 'Special Duck' ) ; // 'Special Duck'

    // Await methods
    await Promise . all ( [
      stub . addFavoriteFood ( 'herring' ) ,
      stub . addFavoriteFood ( 'shrimp' )
    ] ) ;
    const greeting = await stub . sayHello ( ) ; // 'Hello world, my name is Special Duck, and I have 2 favorite foods.'
  
    return new Response ( greeting ) ;
  }
} 

API

Hiperdurável

Use como classe base do seu objeto durável. Inclui algumas propriedades e métodos por padrão, descritos abaixo.

env: Env

O env passado no construtor.

state: HyperState

O state passado no construtor, mais:

state.dirty: Set<string>

Conjunto de propriedades que foram alteradas na memória, mas ainda não persistiram.

state.persisted: Set<string>

Conjunto de propriedades que são persistidas no armazenamento de Objetos Duráveis.

state.tempKey: string

Usado para rastrear a chave de uma propriedade profundamente aninhada (ou seja, ao acessar this.favoriteFoods[0] , state.tempKey é favoriteFoods ).

storage: DurableObjectStorage

Armazenamento de objetos durável, de state.storage .

router: Router

Um roteador itty para lidar com solicitações de busca recebidas.

async initialize()

Inicializa o carregamento se o carregamento ainda não tiver começado.

async load()

Carrega dados persistentes na memória.

async persist()

Persiste propriedades sujas.

async destroy()

Exclui todos os dados em storage , limpa state.dirty e state.persisted e exclui todas as propriedades da memória.

toObject()

Retorna todos os dados persistentes e sujos como um objeto.

async fetch(request: Request): Promise<Response>

Inicializa o objeto (se não tiver sido inicializado anteriormente) e depois passa a solicitação para router . Depois que router trata a solicitação, quaisquer dados sujos persistem.

proxyHyperDurables(env: Env, doBindings: { [key: string]: DOClass })

Use para fazer proxy de seus namespaces de objetos duráveis. Aceita dois parâmetros: env e doBindings . env é o env do seu trabalhador onde os namespaces são acessados. doBindings é um objeto, onde as chaves são nomes de ligação e os valores são as classes de objetos duráveis ​​​​associadas a essas ligações. Retorna um objeto, onde as chaves são os nomes de ligação passados ​​e os valores são os HyperNamespaceProxy associados.

HyperNamespaceProxy

Use para gerar IDs de objetos e obter stubs de objetos, assim como na API DurableObjectNamespace upstream.

HiperStub

Produzido por HyperNamespaceProxy.get(id) . O método fetch pode ser acessado diretamente, como na API upstream. O stub também permite acesso simples a propriedades e métodos.

Para adquirir um imóvel, await :

 await stub . name ;

Para definir uma propriedade, await o setter gerado automaticamente (retorna o novo valor):

 await stub . setName ( 'Eendje' ) ;

Para invocar um método, await -o ( NOTA: Se um método não tiver valor de retorno, ele retornará null em vez do usual undefined ):

 await stub . sayHello ( ) ;

As propriedades e métodos do stub retornarão seus valores diretamente em caso de sucesso. Se a operação falhar, um HyperError será lançado com a seguinte estrutura:

 {
  message : 'Error message' ,
  details : 'Error details'
} 

Agradecimentos especiais

Esta biblioteca foi fortemente inspirada em itty-durable de Kevin Whitley.