@prestack/thread 0.1.3 → 0.1.5

package/dist/operations/metering.js

@@ -1,247 +0,0 @@
-import { PlatformError } from "./errors/catalog.js";
-import { DbRoundTripBudgetExceeded } from "./errors/errors.js";
-import { isTransactional } from "./seams.js";
-export class RoundTripBudgetExceededError extends PlatformError {
-    budget;
-    refusedStatement;
-    constructor(budget, statement) {
-        const detail = `this operation declared a budget of ${budget} database round trip(s) and asked for ` +
-            `"${statement}" as number ${budget + 1}`;
-        super(DbRoundTripBudgetExceeded.def, { detail, because: BUDGET_EXCEEDED_BECAUSE });
-        this.name = 'RoundTripBudgetExceededError';
-        this.message = detail;
-        this.budget = budget;
-        this.refusedStatement = statement;
-    }
-}
-export const BUDGET_EXCEEDED_BECAUSE = 'round_trip_budget_exceeded';
-export const DB_USAGE_PROPERTY = 'db';
-export const DB_USAGE_ATTRIBUTES = {
-    roundTrips: 'thread.db.round_trips',
-    rowsRead: 'thread.db.rows_read',
-    rowsWritten: 'thread.db.rows_written',
-    bytesRead: 'thread.db.bytes_read',
-    bytesWritten: 'thread.db.bytes_written',
-    budgetRoundTrips: 'thread.db.budget_round_trips',
-};
-export const DB_AMPLIFICATION_PROPERTY = 'db_amplification';
-export const DB_AMPLIFICATION_ATTRIBUTES = {
-    entities: 'thread.db.amplified_entities',
-    columns: 'thread.db.amplified_columns',
-    bytes: 'thread.db.amplified_bytes',
-    writes: 'thread.db.amplified_writes',
-};
-export function databaseUsageValues(usage, budget) {
-    return {
-        [DB_USAGE_ATTRIBUTES.roundTrips]: usage.roundTrips,
-        [DB_USAGE_ATTRIBUTES.rowsRead]: usage.rowsRead,
-        [DB_USAGE_ATTRIBUTES.rowsWritten]: usage.rowsWritten,
-        [DB_USAGE_ATTRIBUTES.bytesRead]: usage.bytesRead,
-        [DB_USAGE_ATTRIBUTES.bytesWritten]: usage.bytesWritten,
-        ...(budget === undefined ? {} : { [DB_USAGE_ATTRIBUTES.budgetRoundTrips]: budget.roundTrips }),
-    };
-}
-export function writeAmplificationValues(usage) {
-    if (usage.amplified.length === 0)
-        return undefined;
-    const entities = [...new Set(usage.amplified.map((write) => write.entity))];
-    const columns = [...new Set(usage.amplified.flatMap((write) => write.columns))];
-    return {
-        [DB_AMPLIFICATION_ATTRIBUTES.entities]: entities.join(','),
-        [DB_AMPLIFICATION_ATTRIBUTES.columns]: columns.join(','),
-        [DB_AMPLIFICATION_ATTRIBUTES.bytes]: usage.amplified.reduce((total, write) => total + write.bytes, 0),
-        [DB_AMPLIFICATION_ATTRIBUTES.writes]: usage.amplified.length,
-    };
-}
-const MAX_WALK_DEPTH = 24;
-function utf8Length(text) {
-    let bytes = 0;
-    for (let index = 0; index < text.length; index += 1) {
-        const code = text.charCodeAt(index);
-        if (code < 0x80)
-            bytes += 1;
-        else if (code < 0x800)
-            bytes += 2;
-        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
-            bytes += 4;
-            index += 1;
-        }
-        else
-            bytes += 3;
-    }
-    return bytes;
-}
-export function payloadBytes(value, depth = 0) {
-    if (value === null || value === undefined)
-        return 0;
-    if (depth > MAX_WALK_DEPTH)
-        return 0;
-    switch (typeof value) {
-        case 'string':
-            return utf8Length(value);
-        case 'number':
-        case 'boolean':
-        case 'bigint':
-            return 8;
-        case 'object':
-            break;
-        default:
-            return 0;
-    }
-    if (value instanceof Date)
-        return 8;
-    if (value instanceof Uint8Array)
-        return value.byteLength;
-    if (Array.isArray(value)) {
-        let total = 0;
-        for (const item of value)
-            total += payloadBytes(item, depth + 1);
-        return total;
-    }
-    let total = 0;
-    for (const [key, nested] of Object.entries(value)) {
-        total += utf8Length(key) + payloadBytes(nested, depth + 1);
-    }
-    return total;
-}
-function sameStoredValue(left, right, depth = 0) {
-    if (left === right)
-        return true;
-    if (depth > MAX_WALK_DEPTH)
-        return false;
-    if (left instanceof Date || right instanceof Date) {
-        return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
-    }
-    if (typeof left !== 'object' || typeof right !== 'object' || left === null || right === null)
-        return false;
-    if (Array.isArray(left) !== Array.isArray(right))
-        return false;
-    if (Array.isArray(left) && Array.isArray(right)) {
-        return left.length === right.length && left.every((item, index) => sameStoredValue(item, right[index], depth + 1));
-    }
-    const a = left;
-    const b = right;
-    const keys = Object.keys(a);
-    if (keys.length !== Object.keys(b).length)
-        return false;
-    return keys.every((key) => key in b && sameStoredValue(a[key], b[key], depth + 1));
-}
-export function meterDatabase(seams, budget) {
-    let roundTrips = 0;
-    let rowsRead = 0;
-    let rowsWritten = 0;
-    let bytesRead = 0;
-    let bytesWritten = 0;
-    const amplified = [];
-    const seen = new Map();
-    const remember = (entity, row) => {
-        seen.set(`${entity}:${row.id}`, row);
-    };
-    const spend = (statement) => {
-        if (budget !== undefined && roundTrips >= budget.roundTrips) {
-            throw new RoundTripBudgetExceededError(budget.roundTrips, statement);
-        }
-        roundTrips += 1;
-    };
-    const readRows = (rows) => {
-        rowsRead += rows.length;
-        for (const row of rows)
-            bytesRead += payloadBytes(row);
-    };
-    const base = seams.store;
-    const store = base === undefined ? undefined : {
-        async insert(actor, entity, row) {
-            spend(`insert ${entity}`);
-            bytesWritten += payloadBytes(row);
-            rowsWritten += 1;
-            const written = await base.insert(actor, entity, row);
-            remember(entity, written);
-            return written;
-        },
-        async get(actor, entity, id, fields) {
-            spend(`get ${entity}`);
-            const row = await base.get(actor, entity, id, fields);
-            if (row !== null) {
-                rowsRead += 1;
-                bytesRead += payloadBytes(row);
-                remember(entity, row);
-            }
-            return row;
-        },
-        async list(actor, entity, opts) {
-            spend(`list ${entity}`);
-            const rows = await base.list(actor, entity, opts);
-            readRows(rows);
-            for (const row of rows)
-                remember(entity, row);
-            return rows;
-        },
-        async update(actor, entity, id, patch, expectedVersion) {
-            spend(`update ${entity}`);
-            recordAmplification(entity, id, patch);
-            bytesWritten += payloadBytes(patch);
-            rowsWritten += 1;
-            const row = await base.update(actor, entity, id, patch, expectedVersion);
-            remember(entity, row);
-            return row;
-        },
-        async remove(actor, entity, id) {
-            spend(`remove ${entity}`);
-            rowsWritten += 1;
-            await base.remove(actor, entity, id);
-            seen.delete(`${entity}:${id}`);
-        },
-    };
-    if (base !== undefined && store !== undefined && isTransactional(base)) {
-        store.transaction = (actor, fn) => base.transaction(actor, fn);
-    }
-    function recordAmplification(entity, id, patch) {
-        const stored = seen.get(`${entity}:${id}`);
-        if (stored === undefined)
-            return;
-        const columns = [];
-        let bytes = 0;
-        for (const [column, value] of Object.entries(patch)) {
-            if (!(column in stored))
-                continue;
-            if (!sameStoredValue(value, stored[column]))
-                continue;
-            columns.push(column);
-            bytes += payloadBytes(value);
-        }
-        if (columns.length === 0)
-            return;
-        amplified.push({ entity, id: String(id), columns, bytes });
-    }
-    const views = seams.views === undefined
-        ? undefined
-        : {
-            async query(actor, sql, params) {
-                spend('view');
-                const rows = await seams.views.query(actor, sql, params);
-                readRows(rows);
-                return rows;
-            },
-        };
-    const baseSearch = seams.search;
-    const search = baseSearch === undefined
-        ? undefined
-        : {
-            index: (actor, entity, row) => baseSearch.index(actor, entity, row),
-            async query(actor, entity, q) {
-                spend(`search ${entity}`);
-                const rows = await baseSearch.query(actor, entity, q);
-                readRows(rows);
-                return rows;
-            },
-        };
-    const metered = {
-        ...(store === undefined ? {} : { store }),
-        ...(search === undefined ? {} : { search }),
-        ...(views === undefined ? {} : { views }),
-    };
-    return {
-        seams: { ...seams, ...metered },
-        usage: () => ({ roundTrips, rowsRead, rowsWritten, bytesRead, bytesWritten, amplified }),
-    };
-}

package/dist/operations/metering.ts

@@ -1,328 +0,0 @@
-import { PlatformError } from './errors/catalog.ts'
-import { DbRoundTripBudgetExceeded } from './errors/errors.ts'
-
-import type { Actor } from '../core/actor.ts'
-import type { PropertyValue, Row, Search, Seams, Store, Transactional, Views } from './seams.ts'
-import { isTransactional } from './seams.ts'
-
-export interface ActionBudget {
-
-  readonly roundTrips: number
-}
-
-export interface WriteAmplification {
-  readonly entity: string
-  readonly id: string
-
-  readonly columns: readonly string[]
-
-  readonly bytes: number
-}
-
-export interface DatabaseUsage {
-
-  readonly roundTrips: number
-  readonly rowsRead: number
-  readonly rowsWritten: number
-  readonly bytesRead: number
-  readonly bytesWritten: number
-
-  readonly amplified: readonly WriteAmplification[]
-}
-
-export class RoundTripBudgetExceededError extends PlatformError {
-  readonly budget: number
-
-  readonly refusedStatement: string
-
-  constructor(budget: number, statement: string) {
-    const detail =
-      `this operation declared a budget of ${budget} database round trip(s) and asked for ` +
-      `"${statement}" as number ${budget + 1}`
-
-    super(DbRoundTripBudgetExceeded.def, { detail, because: BUDGET_EXCEEDED_BECAUSE })
-    this.name = 'RoundTripBudgetExceededError'
-
-    this.message = detail
-    this.budget = budget
-    this.refusedStatement = statement
-  }
-}
-
-export const BUDGET_EXCEEDED_BECAUSE = 'round_trip_budget_exceeded'
-
-export const DB_USAGE_PROPERTY = 'db'
-
-export const DB_USAGE_ATTRIBUTES = {
-  roundTrips: 'thread.db.round_trips',
-  rowsRead: 'thread.db.rows_read',
-  rowsWritten: 'thread.db.rows_written',
-  bytesRead: 'thread.db.bytes_read',
-  bytesWritten: 'thread.db.bytes_written',
-  budgetRoundTrips: 'thread.db.budget_round_trips',
-} as const
-
-export const DB_AMPLIFICATION_PROPERTY = 'db_amplification'
-
-export const DB_AMPLIFICATION_ATTRIBUTES = {
-  entities: 'thread.db.amplified_entities',
-  columns: 'thread.db.amplified_columns',
-  bytes: 'thread.db.amplified_bytes',
-  writes: 'thread.db.amplified_writes',
-} as const
-
-export function databaseUsageValues(
-  usage: DatabaseUsage,
-  budget?: ActionBudget,
-): Readonly<Record<string, PropertyValue>> {
-  return {
-    [DB_USAGE_ATTRIBUTES.roundTrips]: usage.roundTrips,
-    [DB_USAGE_ATTRIBUTES.rowsRead]: usage.rowsRead,
-    [DB_USAGE_ATTRIBUTES.rowsWritten]: usage.rowsWritten,
-    [DB_USAGE_ATTRIBUTES.bytesRead]: usage.bytesRead,
-    [DB_USAGE_ATTRIBUTES.bytesWritten]: usage.bytesWritten,
-    ...(budget === undefined ? {} : { [DB_USAGE_ATTRIBUTES.budgetRoundTrips]: budget.roundTrips }),
-  }
-}
-
-export function writeAmplificationValues(
-  usage: DatabaseUsage,
-): Readonly<Record<string, PropertyValue>> | undefined {
-  if (usage.amplified.length === 0) return undefined
-
-  const entities = [...new Set(usage.amplified.map((write) => write.entity))]
-  const columns = [...new Set(usage.amplified.flatMap((write) => write.columns))]
-
-  return {
-    [DB_AMPLIFICATION_ATTRIBUTES.entities]: entities.join(','),
-    [DB_AMPLIFICATION_ATTRIBUTES.columns]: columns.join(','),
-    [DB_AMPLIFICATION_ATTRIBUTES.bytes]: usage.amplified.reduce((total, write) => total + write.bytes, 0),
-    [DB_AMPLIFICATION_ATTRIBUTES.writes]: usage.amplified.length,
-  }
-}
-
-const MAX_WALK_DEPTH = 24
-
-function utf8Length(text: string): number {
-  let bytes = 0
-  for (let index = 0; index < text.length; index += 1) {
-    const code = text.charCodeAt(index)
-    if (code < 0x80) bytes += 1
-    else if (code < 0x800) bytes += 2
-    else if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
-
-      bytes += 4
-      index += 1
-    } else bytes += 3
-  }
-  return bytes
-}
-
-export function payloadBytes(value: unknown, depth = 0): number {
-  if (value === null || value === undefined) return 0
-  if (depth > MAX_WALK_DEPTH) return 0
-
-  switch (typeof value) {
-    case 'string':
-      return utf8Length(value)
-    case 'number':
-    case 'boolean':
-    case 'bigint':
-
-      return 8
-    case 'object':
-      break
-    default:
-
-      return 0
-  }
-
-  if (value instanceof Date) return 8
-  if (value instanceof Uint8Array) return value.byteLength
-  if (Array.isArray(value)) {
-    let total = 0
-    for (const item of value) total += payloadBytes(item, depth + 1)
-    return total
-  }
-
-  let total = 0
-  for (const [key, nested] of Object.entries(value as Record<string, unknown>)) {
-
-    total += utf8Length(key) + payloadBytes(nested, depth + 1)
-  }
-  return total
-}
-
-function sameStoredValue(left: unknown, right: unknown, depth = 0): boolean {
-  if (left === right) return true
-  if (depth > MAX_WALK_DEPTH) return false
-
-  if (left instanceof Date || right instanceof Date) {
-    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime()
-  }
-  if (typeof left !== 'object' || typeof right !== 'object' || left === null || right === null) return false
-  if (Array.isArray(left) !== Array.isArray(right)) return false
-
-  if (Array.isArray(left) && Array.isArray(right)) {
-    return left.length === right.length && left.every((item, index) => sameStoredValue(item, right[index], depth + 1))
-  }
-
-  const a = left as Record<string, unknown>
-  const b = right as Record<string, unknown>
-  const keys = Object.keys(a)
-  if (keys.length !== Object.keys(b).length) return false
-  return keys.every((key) => key in b && sameStoredValue(a[key], b[key], depth + 1))
-}
-
-export interface MeterableSeams {
-  readonly store?: Store
-  readonly search?: Search
-  readonly views?: Views
-}
-
-export interface Metered<S> {
-  readonly seams: S
-
-  usage(): DatabaseUsage
-}
-
-export type MeteredSeams = Metered<Seams>
-
-export function meterDatabase<S extends MeterableSeams>(seams: S, budget?: ActionBudget): Metered<S> {
-  let roundTrips = 0
-  let rowsRead = 0
-  let rowsWritten = 0
-  let bytesRead = 0
-  let bytesWritten = 0
-  const amplified: WriteAmplification[] = []
-
-  const seen = new Map<string, Row>()
-  const remember = (entity: string, row: Row): void => {
-    seen.set(`${entity}:${row.id}`, row)
-  }
-
-  const spend = (statement: string): void => {
-    if (budget !== undefined && roundTrips >= budget.roundTrips) {
-
-      throw new RoundTripBudgetExceededError(budget.roundTrips, statement)
-    }
-    roundTrips += 1
-  }
-
-  const readRows = (rows: readonly unknown[]): void => {
-    rowsRead += rows.length
-    for (const row of rows) bytesRead += payloadBytes(row)
-  }
-
-  const base = seams.store
-
-  const store: (Store & Partial<Transactional>) | undefined = base === undefined ? undefined : {
-    async insert(actor, entity, row) {
-      spend(`insert ${entity}`)
-      bytesWritten += payloadBytes(row)
-      rowsWritten += 1
-      const written = await base.insert(actor, entity, row)
-      remember(entity, written)
-      return written
-    },
-
-    async get(actor, entity, id, fields) {
-      spend(`get ${entity}`)
-      const row = await base.get(actor, entity, id, fields)
-      if (row !== null) {
-        rowsRead += 1
-        bytesRead += payloadBytes(row)
-        remember(entity, row)
-      }
-      return row
-    },
-
-    async list(actor, entity, opts) {
-      spend(`list ${entity}`)
-      const rows = await base.list(actor, entity, opts)
-      readRows(rows)
-      for (const row of rows) remember(entity, row)
-      return rows
-    },
-
-    async update(actor, entity, id, patch, expectedVersion) {
-      spend(`update ${entity}`)
-      recordAmplification(entity, id, patch)
-      bytesWritten += payloadBytes(patch)
-      rowsWritten += 1
-      const row = await base.update(actor, entity, id, patch, expectedVersion)
-      remember(entity, row)
-      return row
-    },
-
-    async remove(actor, entity, id) {
-
-      spend(`remove ${entity}`)
-      rowsWritten += 1
-      await base.remove(actor, entity, id)
-      seen.delete(`${entity}:${id}`)
-    },
-  }
-
-  if (base !== undefined && store !== undefined && isTransactional(base)) {
-    store.transaction = (actor, fn) => base.transaction(actor, fn)
-  }
-
-  function recordAmplification(entity: string, id: string | number, patch: Record<string, unknown>): void {
-    const stored = seen.get(`${entity}:${id}`)
-    if (stored === undefined) return
-
-    const columns: string[] = []
-    let bytes = 0
-    for (const [column, value] of Object.entries(patch)) {
-      if (!(column in stored)) continue
-      if (!sameStoredValue(value, stored[column])) continue
-      columns.push(column)
-      bytes += payloadBytes(value)
-    }
-
-    if (columns.length === 0) return
-    amplified.push({ entity, id: String(id), columns, bytes })
-  }
-
-  const views: Views | undefined =
-    seams.views === undefined
-      ? undefined
-      : {
-          async query<T = Record<string, unknown>>(
-            actor: Actor,
-            sql: string,
-            params: readonly unknown[],
-          ): Promise<readonly T[]> {
-            spend('view')
-            const rows = await (seams.views as Views).query<T>(actor, sql, params)
-            readRows(rows)
-            return rows
-          },
-        }
-
-  const baseSearch = seams.search
-  const search: Search | undefined =
-    baseSearch === undefined
-      ? undefined
-      : {
-          index: (actor, entity, row) => baseSearch.index(actor, entity, row),
-          async query(actor, entity, q) {
-            spend(`search ${entity}`)
-            const rows = await baseSearch.query(actor, entity, q)
-            readRows(rows)
-            return rows
-          },
-        }
-
-  const metered: MeterableSeams = {
-    ...(store === undefined ? {} : { store }),
-    ...(search === undefined ? {} : { search }),
-    ...(views === undefined ? {} : { views }),
-  }
-
-  return {
-    seams: { ...seams, ...metered } as S,
-    usage: () => ({ roundTrips, rowsRead, rowsWritten, bytesRead, bytesWritten, amplified }),
-  }
-}

package/dist/operations/queue-policy.d.ts

@@ -1,3 +0,0 @@
-export declare const MAX_ATTEMPTS = 5;
-export declare function backoffMs(attempts: number): number;
-export declare function isExhausted(attempts: number): boolean;

package/dist/operations/queue-policy.js

@@ -1,8 +0,0 @@
-export const MAX_ATTEMPTS = 5;
-export function backoffMs(attempts) {
-    const base = 1_000 * 2 ** Math.max(0, attempts - 1);
-    return Math.min(base, 5 * 60_000);
-}
-export function isExhausted(attempts) {
-    return attempts >= MAX_ATTEMPTS;
-}

package/dist/operations/queue-policy.ts

@@ -1,10 +0,0 @@
-export const MAX_ATTEMPTS = 5
-
-export function backoffMs(attempts: number): number {
-  const base = 1_000 * 2 ** Math.max(0, attempts - 1)
-  return Math.min(base, 5 * 60_000)
-}
-
-export function isExhausted(attempts: number): boolean {
-  return attempts >= MAX_ATTEMPTS
-}