hyper durable

ไฮเปอร์ทนทาน

HyperDurable เป็นคลาสพื้นฐานสำหรับ Durability Objects ที่ช่วยให้สามารถเข้าถึงพื้นที่จัดเก็บข้อมูลถาวรที่ซ่อนอยู่ได้อย่างเป็นธรรมชาติจาก Stubs Durable Object HyperDurable สรุป API การดึงวัตถุที่ทนทานอย่างสมบูรณ์ ปรับปรุงความสามารถในการอ่านโค้ดในเลเยอร์ตรรกะทางธุรกิจ

• บทคัดย่อออกไป API การดึงวัตถุที่ทนทาน
• เก็บข้อมูลสกปรกโดยอัตโนมัติ
• สร้างด้วย TypeScript
• ชุดทดสอบที่ครอบคลุม

การติดตั้ง

ด้วยเส้นด้าย:

yarn add @ticketbridge/hyper-durable

ด้วย NPM:

npm i @ticketbridge/hyper-durable

การใช้งาน

เขียนคลาสวัตถุคงทนของคุณโดยขยายคลาสพื้นฐาน HyperDurable ใน Constructor ให้ส่ง state และ env ไปที่ HyperDurable ผ่าน super() HyperDurable จะโหลดข้อมูลที่มีอยู่ก่อนหน้านี้ทั้งหมดลงในหน่วยความจำภายใน fetch ดังนั้นคุณสมบัติใด ๆ ที่คุณตั้งค่าใน Constructor หลังจากเรียกใช้ super() จะถูกแทนที่โดยข้อมูลที่มีอยู่ก่อนหน้านี้

ภายในวัตถุคงทนของคุณ ให้เข้าถึงคุณสมบัติและวิธีการในหน่วยความจำโดยใช้ this . ไม่ต้องกังวลกับการคงอยู่ ข้อมูลสกปรกจะคงอยู่เมื่อสิ้นสุดคำขอดึงข้อมูลทุกครั้ง

 // 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.` ;
  }
}

ในผู้ปฏิบัติงานของคุณ ก่อนอื่นให้พร็อกซีเนมสเปซวัตถุคงทนของคุณด้วย proxyHyperDurables การได้รับ stub จะไม่เปลี่ยนแปลง: สร้าง id ของคุณด้วยวิธีที่คุณต้องการจาก namespace API (เช่น newUniqueId , idFromName , idFromString ) จากนั้นใช้ get เพื่อสร้าง stub อ็อบเจ็กต์

การดำเนินการ stub ทั้งหมดต้อง await การแก้ไข เนื่องจากการดำเนินการทั้งหมดใช้ fetch API ภายใต้ประทุน คุณสมบัติสามารถอ่านได้โดยตรงจากต้นขั้ว คุณสมบัติสามารถตั้งค่าได้ด้วยตัวตั้งค่าที่สร้างขึ้นอัตโนมัติ (ในรูปแบบ set + PropName ) สามารถเรียกเมธอดได้โดยตรงจาก 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 ) ;
  }
} 

เอพีไอ

ไฮเปอร์ทนทาน

ใช้เป็นคลาสพื้นฐานของวัตถุคงทนของคุณ รวมคุณสมบัติและวิธีการบางอย่างตามค่าเริ่มต้น ซึ่งจะอธิบายไว้ด้านล่างนี้

env: Env

env ส่งผ่านในตัวสร้าง

state: HyperState

state ผ่านตัวสร้างบวก:

state.dirty: Set<string>

ชุดของคุณสมบัติที่มีการเปลี่ยนแปลงในหน่วยความจำแต่ยังไม่มีการคงอยู่

state.persisted: Set<string>

ชุดของคุณสมบัติที่ยังคงอยู่ในที่เก็บวัตถุทนทาน

state.tempKey: string

ใช้เพื่อติดตามคีย์ของคุณสมบัติที่ซ้อนกันลึก (เช่น เมื่อเข้าถึง this.favoriteFoods[0] , state.tempKey จะเป็น favoriteFoods )

storage: DurableObjectStorage

การจัดเก็บวัตถุที่ทนทานจาก state.storage

router: Router

itty-router เพื่อจัดการคำขอดึงข้อมูลที่เข้ามา

async initialize()

เริ่มต้นการโหลดหากยังไม่ได้เริ่มการโหลด

async load()

โหลดข้อมูลที่มีอยู่ในหน่วยความจำ

async persist()

คงคุณสมบัติสกปรก

async destroy()

ลบข้อมูลทั้งหมดใน storage ข้อมูล ล้าง state.dirty และ state.persisted และลบคุณสมบัติทั้งหมดออกจากหน่วยความจำ

toObject()

ส่งคืนข้อมูลที่คงอยู่และสกปรกทั้งหมดเป็นออบเจ็กต์

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

เตรียมใช้งานวัตถุ (หากไม่ได้เตรียมใช้งานก่อนหน้านี้) จากนั้นส่งคำขอไป router หลังจากที่ router จัดการคำขอแล้ว จะยังคงมีข้อมูลที่สกปรกอยู่

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

ใช้เพื่อพร็อกซีเนมสเปซวัตถุคงทนของคุณ ยอมรับสองพารามิเตอร์: env และ doBindings env คือ env ของผู้ปฏิบัติงานของคุณที่มีการเข้าถึงเนมสเปซ doBindings เป็นอ็อบเจ็กต์ โดยที่คีย์เป็น ชื่อการโยง และค่าเป็น คลาสอ็อบเจ็กต์คงทน ที่เกี่ยวข้องกับการโยงเหล่านั้น ส่งคืนอ็อบเจ็กต์ โดยที่คีย์เป็น ชื่อการเชื่อมโยง ที่ส่งผ่าน และค่าเป็น HyperNamespaceProxy ที่เกี่ยวข้อง

HyperNamespaceProxy

ใช้เพื่อสร้าง ID อ็อบเจ็กต์และรับ stub อ็อบเจ็กต์ เช่นเดียวกับใน DurableObjectNamespace API อัปสตรีม

ไฮเปอร์สตับ

ผลิตโดย HyperNamespaceProxy.get(id) สามารถเข้าถึงวิธี fetch ได้โดยตรง เช่นเดียวกับใน API อัปสตรีม ต้นขั้วยังช่วยให้สามารถเข้าถึงคุณสมบัติและวิธีการได้อย่างง่ายดาย

หากต้องการรับทรัพย์สิน await :

 await stub . name ;

หากต้องการตั้งค่าคุณสมบัติ await ตัวตั้งค่าที่สร้างขึ้นอัตโนมัติ (ส่งคืนค่าใหม่):

 await stub . setName ( 'Eendje' ) ;

หากต้องการเรียกใช้เมธอด await ( หมายเหตุ: หากเมธอดไม่มีค่าที่ส่งคืน ก็จะส่งคืน null แทนที่จะเป็นค่าปกติ undefined ):

 await stub . sayHello ( ) ;

คุณสมบัติและวิธีการของ Stub จะส่งกลับค่าโดยตรงในกรณีที่ประสบความสำเร็จ หากการดำเนินการล้มเหลว HyperError จะถูกส่งออกไปพร้อมกับโครงสร้างต่อไปนี้:

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

ขอขอบคุณเป็นพิเศษ

ห้องสมุดนี้ได้รับแรงบันดาลใจอย่างมากจาก itty-durable จาก Kevin Whitley