wirejs-resources 0.1.28 → 0.1.30-table-resource

package/dist/index.d.ts

@@ -6,5 +6,6 @@ export { withContext, requiresContext, Context, ContextWrapped } from './adapter
 export { Resource } from './resource.js';
 export { overrides } from './overrides.js';
 export { Secret } from './resources/secret.js';
+export { DistributedTable, DistributedTableOptions, Filter, FieldComparison, FieldComparisonOptions, FieldType, Parser, PassThruParser, RecordType, RecordKey, matchesFilter, } from './resources/distributed-table.js';
 export * from './types.js';
 export * from './derived-types.js';

package/dist/index.js

@@ -6,5 +6,6 @@ export { withContext, requiresContext, Context } from './adapters/context.js';
 export { Resource } from './resource.js';
 export { overrides } from './overrides.js';
 export { Secret } from './resources/secret.js';
+export { DistributedTable, PassThruParser, matchesFilter, } from './resources/distributed-table.js';
 export * from './types.js';
 export * from './derived-types.js';

package/dist/overrides.d.ts

@@ -5,7 +5,8 @@ import type { Secret } from "./resources/secret";
  * Used by hosting providers to provide service overrides.
  */
 export declare const overrides: {
-    FileService?: typeof FileService;
     AuthenticationService?: typeof AuthenticationService;
+    DistributedTable?: typeof AuthenticationService;
+    FileService?: typeof FileService;
     Secret?: typeof Secret;
 };

package/dist/resources/distributed-table.d.ts

@@ -0,0 +1,81 @@
+import { Resource } from '../resource.js';
+export type DistributedTableOptions<T> = {
+    parse: Parser<T>;
+    key: {
+        partition: keyof T & string;
+        sort?: (keyof T & string)[];
+    };
+};
+export type Parser<T> = (record: Record<string, any>) => T;
+export type RecordType<T extends DistributedTableOptions<any>> = T extends DistributedTableOptions<infer IT> ? IT : Record<string, any>;
+export type RecordKey<T, PK extends keyof T, SK extends (keyof T)[] | undefined> = Pick<T, PK | (SK extends string[] ? SK[number] : never)>;
+export type FieldType<T> = undefined extends T ? (T | null) : T;
+export type FieldComparisonOptions<T> = {
+    [K in keyof T & string]?: {
+        eq: FieldType<T[K]>;
+    } | {
+        ne: FieldType<T[K]>;
+    } | {
+        gt: FieldType<T[K]>;
+    } | {
+        ge: FieldType<T[K]>;
+    } | {
+        lt: FieldType<T[K]>;
+    } | {
+        le: FieldType<T[K]>;
+    } | {
+        between: [FieldType<T[K]>, FieldType<T[K]>];
+    } | {
+        beginsWith: FieldType<T[K]>;
+    };
+};
+export type FieldComparison<T> = {
+    [K in keyof FieldComparisonOptions<T>]: Record<K, FieldComparisonOptions<T>[K]> & NoneOf<Exclude<keyof FieldComparisonOptions<T>, K>>;
+}[keyof FieldComparisonOptions<T>];
+export type NoneOf<Fields> = {
+    [K in Fields & string]?: never;
+};
+export type Filter<T> = (FieldComparison<T> & NoneOf<'and' | 'or' | 'not'>) | ({
+    and: (Filter<T>)[];
+} & NoneOf<keyof T | 'or' | 'not'>) | ({
+    or: (Filter<T>)[];
+} & NoneOf<keyof T | 'and' | 'not'>) | ({
+    not: Filter<T>;
+} & NoneOf<keyof T | 'and' | 'or'>);
+export declare function matchesFilter<T>(record: T, filter: Filter<T>): boolean;
+export declare function PassThruParser<T>(record: Record<string, any>): T;
+/**
+ * A table of records that favors very high *overall* scalability at the expense of
+ * scalability *between* partitions. Providers will distribute your data across many
+ * servers based on the partition key as the table and/or traffic increases.
+ *
+ * ### Do NOT change partition keys. (In Production.)
+ *
+ * Changing it will cause some providers to drop and recreate your table.
+ *
+ * High cardinality, non-sequential partition keys allow for the best overall scaling.
+ */
+export declare class DistributedTable<const P extends Parser<any>, const T extends ReturnType<P>, const PK extends keyof T & string, const SK extends (keyof T & string)[] | undefined> extends Resource {
+    #private;
+    parse: P;
+    partitionKey: PK;
+    sort: SK | undefined;
+    constructor(scope: Resource | string, id: string, options: {
+        parse: P;
+        key: {
+            partition: PK;
+            sort?: SK;
+        };
+    });
+    save(item: T): Promise<void>;
+    saveMany(items: T[]): Promise<void>;
+    delete(item: RecordKey<T, PK, SK>): Promise<void>;
+    deleteMany(items: (RecordKey<T, PK, SK>)[]): Promise<void>;
+    get(key: RecordKey<T, PK, SK>): Promise<T | undefined>;
+    scan(options: {
+        filter?: Filter<T>;
+    }): AsyncGenerator<T>;
+    query(partition: Pick<T, PK>, options?: {
+        filter?: Filter<T>;
+    }): AsyncGenerator<T>;
+}

package/dist/resources/distributed-table.js

@@ -0,0 +1,130 @@
+import { Resource } from '../resource.js';
+import { FileService } from '../services/file.js';
+import { overrides } from '../overrides.js';
+export function matchesFilter(record, filter) {
+    if (filter.and) {
+        return filter.and.every(sub => matchesFilter(record, sub));
+    }
+    if (filter.or) {
+        return filter.or.some(sub => matchesFilter(record, sub));
+    }
+    if (filter.not) {
+        return !matchesFilter(record, filter.not);
+    }
+    for (const [field, fieldFilter] of Object.entries(filter)) {
+        const value = record[field];
+        if ('eq' in fieldFilter && value !== fieldFilter.eq)
+            return false;
+        if ('ne' in fieldFilter && value === fieldFilter.ne)
+            return false;
+        if ('gt' in fieldFilter && value <= fieldFilter.gt)
+            return false;
+        if ('ge' in fieldFilter && value < fieldFilter.ge)
+            return false;
+        if ('lt' in fieldFilter && value >= fieldFilter.lt)
+            return false;
+        if ('le' in fieldFilter && value > fieldFilter.le)
+            return false;
+        if ('between' in fieldFilter) {
+            const [low, high] = fieldFilter.between;
+            if (value < low || value > high)
+                return false;
+        }
+        if ('beginsWith' in fieldFilter) {
+            if (typeof value !== 'string' || !value.startsWith(fieldFilter.beginsWith)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+export function PassThruParser(record) {
+    return record;
+}
+/**
+ * A table of records that favors very high *overall* scalability at the expense of
+ * scalability *between* partitions. Providers will distribute your data across many
+ * servers based on the partition key as the table and/or traffic increases.
+ *
+ * ### Do NOT change partition keys. (In Production.)
+ *
+ * Changing it will cause some providers to drop and recreate your table.
+ *
+ * High cardinality, non-sequential partition keys allow for the best overall scaling.
+ */
+export class DistributedTable extends Resource {
+    parse;
+    partitionKey;
+    sort;
+    #fileService;
+    constructor(scope, id, options) {
+        super(scope, id);
+        this.parse = options.parse;
+        this.partitionKey = options.key.partition;
+        this.sort = options.key.sort;
+        this.#fileService = new (overrides.FileService || FileService)(this, 'files');
+    }
+    #getFilename(key) {
+        const parts = [key[this.partitionKey]];
+        if (this.sort) {
+            for (const sk of this.sort) {
+                parts.push(key[sk]);
+            }
+        }
+        return parts.map(String).join('__') + '.json';
+    }
+    async save(item) {
+        const key = this.#getFilename(item);
+        await this.#fileService.write(key, JSON.stringify(item));
+    }
+    async saveMany(items) {
+        const promises = items.map(item => {
+            const key = this.#getFilename(item);
+            return this.#fileService.write(key, JSON.stringify(item));
+        });
+        await Promise.all(promises);
+    }
+    async delete(item) {
+        const key = this.#getFilename(item);
+        await this.#fileService.delete(key);
+    }
+    async deleteMany(items) {
+        const promises = items.map(item => {
+            const key = this.#getFilename(item);
+            return this.#fileService.delete(key);
+        });
+        await Promise.all(promises);
+    }
+    async get(key) {
+        try {
+            const filename = this.#getFilename(key);
+            const data = await this.#fileService.read(filename);
+            return this.parse(JSON.parse(data));
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return undefined;
+            throw err;
+        }
+    }
+    async *scan(options) {
+        for await (const filename of this.#fileService.list()) {
+            const data = await this.#fileService.read(filename);
+            const record = this.parse(JSON.parse(data));
+            if (!options.filter || matchesFilter(record, options.filter)) {
+                yield record;
+            }
+        }
+    }
+    async *query(partition, options = {}) {
+        const prefix = partition[this.partitionKey];
+        for await (const filename of this.#fileService.list({ prefix })) {
+            const data = await this.#fileService.read(filename);
+            const record = this.parse(JSON.parse(data));
+            if (record[this.partitionKey] === partition[this.partitionKey]
+                && (!options.filter || matchesFilter(record, options.filter))) {
+                yield record;
+            }
+        }
+    }
+}

package/dist/services/file.d.ts

@@ -9,7 +9,7 @@ export declare class FileService extends Resource {
     delete(filename: string): Promise<void>;
     list({ prefix }?: {
         prefix?: string | undefined;
-    }): AsyncGenerator<string, void, unknown>;
+    }): AsyncGenerator<string>;
     isAlreadyExistsError(error: {
         code: any;
     }): boolean;

package/dist/services/file.js

@@ -27,11 +27,21 @@ export class FileService extends Resource {
     }
     async *list({ prefix = '' } = {}) {
         const root = this.#fullNameFor('');
-        const all = await fs.promises.readdir(root, { recursive: true });
-        for (const name of all) {
-            if (prefix === undefined
-                || name.slice(0, root.length).startsWith(prefix)) {
-                yield name;
+        try {
+            const all = await fs.promises.readdir(root, { recursive: true });
+            for (const name of all) {
+                if (prefix === undefined
+                    || name.slice(0, root.length).startsWith(prefix)) {
+                    yield name;
+                }
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return;
+            }
+            else {
+                throw error;
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-resources",
-	"version": "0.1.28",
+	"version": "0.1.30-table-resource",
 	"description": "Basic services and server-side resources for wirejs apps",
 	"type": "module",
 	"main": "./dist/index.js",