jotdb 0.1.8 → 0.1.9

package/dist/site-worker.js

@@ -0,0 +1,6 @@
+export { JotDB } from './index';
+export default {
+    async fetch(request, env) {
+        return env.ASSETS.fetch(request);
+    },
+};

package/dist/src/index.d.ts

@@ -0,0 +1,107 @@
+import { Hono } from 'hono';
+import { DurableObject } from "cloudflare:workers";
+type SchemaType = "string" | "number" | "boolean" | "email" | "array" | "object" | "any";
+interface FieldDescriptor {
+    type: SchemaType;
+    default?: unknown;
+    optional?: boolean;
+}
+type FieldSpec = SchemaType | FieldDescriptor;
+type ObjectSchema = Record<string, FieldSpec>;
+type ArraySchema = {
+    __arrayType: SchemaType | ObjectSchema;
+};
+type SchemaDefinition = ObjectSchema | ArraySchema;
+interface JotDBOptions {
+    autoStrip: boolean;
+    readOnly: boolean;
+}
+interface AuditLogEntry {
+    timestamp: number;
+    action: string;
+    keys: string[];
+}
+export declare class JotDB extends DurableObject {
+    private data;
+    private rawSchema;
+    private zodSchema;
+    private options;
+    private auditLog;
+    private store;
+    constructor(state: any, env: Env);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    isArrayMode(): boolean;
+    private inferSchemaFromValue;
+    push(item: unknown): Promise<void>;
+    private applyDefaultsForObjectSchema;
+    setAll(objOrArr: Record<string, unknown> | unknown[]): Promise<void>;
+    getAll(): Promise<unknown>;
+    logAudit(action: string, keys: string[] | string): Promise<void>;
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    has(key: string): Promise<boolean>;
+    getSchema(): Promise<SchemaDefinition>;
+    private warnSchemaDiff;
+    setSchema(schemaObj: SchemaDefinition): Promise<void>;
+    /**
+     * Non-destructively merge additional fields into the current object schema.
+     * Useful for additive schema evolution without a full migration.
+     * Throws if the current schema is an array schema.
+     * New fields with `default` are backfilled into existing stored data.
+     * New fields without `default` and without `optional: true` will cause
+     * existing stored objects to fail validation on next write — prefer adding
+     * `default` or `optional: true` for safe rollouts.
+     */
+    extendSchema(partial: ObjectSchema): Promise<void>;
+    /**
+     * Validate arbitrary data (or current stored data if omitted) against the
+     * current schema without throwing. Returns `{ ok, errors, data }` where
+     * `data` is the (possibly default-applied / coerced) parsed result on
+     * success. If no schema is set, returns `{ ok: true }`.
+     */
+    validate(data?: unknown): Promise<{
+        ok: boolean;
+        errors?: string[];
+        data?: unknown;
+    }>;
+    /**
+     * Apply a transform to the stored data. For object mode, `fn` is called once
+     * with the entire object and must return the new object. For array mode, `fn`
+     * is called once per item and must return the replacement item (return
+     * undefined to drop the item).
+     * If a schema is set, the resulting data is validated before being saved;
+     * on validation failure the original data is left untouched and the function
+     * throws. Records an audit entry on success.
+     */
+    migrate(fn: (value: any, key?: string | number) => any): Promise<void>;
+    setOptions(opts: Partial<JotDBOptions>): Promise<void>;
+    getOptions(): Promise<JotDBOptions>;
+    getAuditLog(): Promise<AuditLogEntry[]>;
+    clearAuditLog(): Promise<void>;
+    private buildZodSchema;
+    private applyObjectDefaults;
+    fetch(request: Request): Promise<Response>;
+    scan<T = unknown>(prefix?: string, options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        items: T[];
+        cursor?: string;
+    }>;
+    append<T = unknown>(stream: string, value: T): Promise<string>;
+    appendCapped<T = unknown>(stream: string, value: T, max: number): Promise<string>;
+    retention(prefix: string, maxAgeMs: number): Promise<void>;
+    set(key: string, value: unknown): Promise<void>;
+}
+export interface Env {
+    JOTDB: DurableObjectNamespace;
+    BENCH_TOKEN: string;
+    HTTP_ENABLED?: string;
+}
+declare const app: Hono<{
+    Bindings: Env;
+}, import("hono/types").BlankSchema, "/">;
+export default app;