@travetto/model 5.0.0-rc.1 → 5.0.0-rc.11

package/support/test/crud.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert';
+import timers from 'node:timers/promises';
 
 import { Suite, Test } from '@travetto/test';
 import { Schema, Text, Precision, Required, } from '@travetto/schema';
@@ -48,7 +49,7 @@ class User2 {
   name: string;
 
   prePersist() {
-    this.name = `${this.name}-suff`;
+    this.name = `${this.name}-suffix`;
   }
 }
 
@@ -192,7 +193,7 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
     }));
 
     assert(o.address === undefined);
-    assert(o.name === 'bob-suff');
+    assert(o.name === 'bob-suffix');
 
     await service.updatePartial(User2, User2.from({
       id: o.id,
@@ -216,7 +217,7 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(res.createdDate instanceof Date);
   }
 
-  @Test('verify prepersist on create/update')
+  @Test('verify pre-persist on create/update')
   async testPrePersist() {
     const service = await this.service;
     const res = await service.create(Dated, Dated.from({}));
@@ -224,7 +225,7 @@ export abstract class ModelCrudSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(res.createdDate instanceof Date);
     assert(res.updatedDate instanceof Date);
 
-    await new Promise(r => setTimeout(r, 100));
+    await timers.setTimeout(100);
 
     const final = await service.updatePartial(Dated, { id: res.id });
     assert(final.createdDate instanceof Date);

package/support/test/expiry.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert';
 import timers from 'node:timers/promises';
 
 import { Suite, Test } from '@travetto/test';
-import { TimeSpan, TimeUnit, TimeUtil } from '@travetto/base';
+import { TimeSpan, TimeUnit, TimeUtil } from '@travetto/runtime';
 
 import { ExpiresAt, Model } from '../../src/registry/decorator';
 import { ModelExpirySupport } from '../../src/service/expiry';

package/support/test/indexed.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert';
 
 import { Suite, Test } from '@travetto/test';
 import { Schema } from '@travetto/schema';
-import { TimeUtil } from '@travetto/base';
+import { TimeUtil } from '@travetto/runtime';
 
 import { Index, Model } from '../../src/registry/decorator';
 import { ModelIndexedSupport } from '../../src/service/indexed';

package/support/test/polymorphism.ts

@@ -12,6 +12,7 @@ import { isIndexedSupported } from '../../src/internal/service/common';
 import { ExistsError } from '../../src/error/exists';
 
 import { BaseModelSuite } from './base';
+import { castTo } from '@travetto/runtime';
 
 @Model({ baseType: true })
 export class Worker {
@@ -70,7 +71,7 @@ export class IndexedEngineer extends IndexedWorker {
 }
 
 async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
-  const out = [] as T[];
+  const out: T[] = [];
   for await (const el of iterable) {
     out.push(el);
   }
@@ -116,12 +117,12 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
 
     const fire3 = all.find(x => x instanceof Firefighter);
     assert(fire3 instanceof Firefighter);
-    assert((fire3 as Firefighter).firehouse === 20);
+    assert(fire3.firehouse === 20);
     assert(fire3.name === 'rob');
 
     const eng3 = all.find(x => x instanceof Engineer);
     assert(eng3 instanceof Engineer);
-    assert((eng3 as Engineer).major === 'oranges');
+    assert(eng3.major === 'oranges');
     assert(eng3.name === 'cob');
 
     const engineers = await collect(service.list(Engineer));
@@ -161,7 +162,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
     );
 
     await assert.rejects(
-      () => service.update(Engineer, Doctor.from({ ...doc }) as unknown as Engineer),
+      () => service.update(Engineer, castTo(Doctor.from({ ...doc }))),
       (e: Error) => (e instanceof NotFoundError || e instanceof SubTypeNotSupportedError || e instanceof TypeMismatchError) ? undefined : e);
 
     await timers.setTimeout(15);
@@ -205,7 +206,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
 
   @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(isIndexedSupported) })
   async polymorphicIndexGet() {
-    const service = (await this.service) as unknown as ModelIndexedSupport;
+    const service: ModelIndexedSupport = castTo(await this.service);
     const now = 30;
     const [doc, fire, eng] = [
       IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),
@@ -235,7 +236,7 @@ export abstract class ModelPolymorphismSuite extends BaseModelSuite<ModelCrudSup
 
   @Test('Polymorphic index', { skip: BaseModelSuite.ifNot(isIndexedSupported) })
   async polymorphicIndexDelete() {
-    const service = (await this.service) as unknown as ModelIndexedSupport;
+    const service: ModelIndexedSupport = castTo(await this.service);
     const now = 30;
     const [doc, fire, eng] = [
       IndexedDoctor.from({ name: 'bob', specialty: 'feet', age: now }),

package/support/test/suite.ts

@@ -1,10 +1,10 @@
-import { Class } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 import { DependencyRegistry } from '@travetto/di';
 import { RootRegistry } from '@travetto/registry';
 import { SuiteRegistry, TestFixtures } from '@travetto/test';
 
-import { isStorageSupported, isStreamSupported } from '../../src/internal/service/common';
-import { StreamModel } from '../../src/internal/service/stream';
+import { isBlobSupported, isStorageSupported } from '../../src/internal/service/common';
+import { MODEL_BLOB } from '../../src/internal/service/blob';
 import { ModelRegistry } from '../../src/registry/model';
 
 const Loaded = Symbol();
@@ -61,11 +61,11 @@ export function ModelSuite<T extends { configClass: Class<{ autoCreate?: boolean
                 }
               }
             }
-            if (isStreamSupported(service)) {
+            if (isBlobSupported(service)) {
               if (service.truncateModel) {
-                await service.truncateModel(StreamModel);
+                await service.truncateModel(MODEL_BLOB);
               } else if (service.deleteModel) {
-                await service.deleteModel(StreamModel);
+                await service.deleteModel(MODEL_BLOB);
               }
             }
           } else {

package/src/internal/service/stream.ts

@@ -1,22 +0,0 @@
-import { AppError, Class } from '@travetto/base';
-
-import { ModelType } from '../../types/model';
-import { StreamRange } from '../../service/stream';
-
-class Cls { id: string; }
-export const StreamModel: Class<ModelType> = Cls;
-export const STREAMS = '_streams';
-
-
-/**
- * Enforce byte range for stream stream/file of a certain size
- */
-export function enforceRange({ start, end }: StreamRange, size: number): Required<StreamRange> {
-  end = Math.min(end ?? size - 1, size - 1);
-
-  if (Number.isNaN(start) || Number.isNaN(end) || !Number.isFinite(start) || start >= size || start < 0 || start > end) {
-    throw new AppError('Invalid position, out of range', 'data');
-  }
-
-  return { start, end };
-}

package/src/provider/file.ts

@@ -1,233 +0,0 @@
-import fs from 'node:fs/promises';
-import { createReadStream, createWriteStream } from 'node:fs';
-import os from 'node:os';
-import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import path from 'node:path';
-
-import { Class, TimeSpan, RuntimeContext } from '@travetto/base';
-import { Injectable } from '@travetto/di';
-import { Config } from '@travetto/config';
-import { Required } from '@travetto/schema';
-
-import { ModelCrudSupport } from '../service/crud';
-import { ModelStreamSupport, StreamMeta, StreamRange } from '../service/stream';
-import { ModelType, OptionalId } from '../types/model';
-import { ModelExpirySupport } from '../service/expiry';
-import { ModelRegistry } from '../registry/model';
-import { ModelStorageSupport } from '../service/storage';
-import { ModelCrudUtil } from '../internal/service/crud';
-import { ModelExpiryUtil } from '../internal/service/expiry';
-import { NotFoundError } from '../error/not-found';
-import { ExistsError } from '../error/exists';
-import { enforceRange, StreamModel, STREAMS } from '../internal/service/stream';
-
-type Suffix = '.bin' | '.meta' | '.json' | '.expires';
-
-const BIN = '.bin';
-const META = '.meta';
-
-@Config('model.file')
-export class FileModelConfig {
-  @Required(false)
-  folder: string;
-  namespace: string = '.';
-  autoCreate?: boolean;
-  cullRate?: number | TimeSpan;
-
-  async postConstruct(): Promise<void> {
-    this.folder ??= path.resolve(os.tmpdir(), `trv_file_${RuntimeContext.main.name.replace(/[^a-z]/ig, '_')}`);
-  }
-}
-
-const exists = (f: string): Promise<boolean> => fs.stat(f).then(() => true, () => false);
-
-/**
- * Standard file support
- */
-@Injectable()
-export class FileModelService implements ModelCrudSupport, ModelStreamSupport, ModelExpirySupport, ModelStorageSupport {
-
-  private static async * scanFolder(folder: string, suffix: string): AsyncGenerator<[id: string, field: string]> {
-    for (const sub of await fs.readdir(folder)) {
-      for (const file of await fs.readdir(path.resolve(folder, sub))) {
-        if (file.endsWith(suffix)) {
-          yield [file.replace(suffix, ''), path.resolve(folder, sub, file)];
-        }
-      }
-    }
-  }
-
-  idSource = ModelCrudUtil.uuidSource();
-
-  get client(): string {
-    return this.config.folder;
-  }
-
-  /**
-   * The root location for all activity
-   */
-  constructor(public readonly config: FileModelConfig) { }
-
-  async #resolveName<T extends ModelType>(cls: Class<T> | string, suffix?: Suffix, id?: string): Promise<string> {
-    const name = typeof cls === 'string' ? cls : ModelRegistry.getStore(cls);
-    let resolved = path.resolve(this.config.folder, this.config.namespace, name);
-    if (id) {
-      resolved = path.resolve(resolved, id.replace(/^[/]/, '').substring(0, 3));
-    }
-    let dir = resolved;
-    if (id) {
-      resolved = path.resolve(resolved, `${id}${suffix}`);
-      dir = path.dirname(resolved);
-    }
-
-    await fs.mkdir(dir, { recursive: true });
-    return resolved;
-  }
-
-  async #find<T extends ModelType>(cls: Class<T> | string, suffix: Suffix, id?: string): Promise<string> {
-    const file = await this.#resolveName(cls, suffix, id);
-    if (id && !(await exists(file))) {
-      throw new NotFoundError(cls, id);
-    }
-    return file;
-  }
-
-  postConstruct(): void {
-    ModelExpiryUtil.registerCull(this);
-  }
-
-  checkExpiry<T extends ModelType>(cls: Class<T>, item: T): T {
-    const { expiresAt } = ModelRegistry.get(cls);
-    if (expiresAt && ModelExpiryUtil.getExpiryState(cls, item).expired) {
-      throw new NotFoundError(cls, item.id);
-    }
-    return item;
-  }
-
-  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
-    await this.#find(cls, '.json', id);
-
-    const file = await this.#resolveName(cls, '.json', id);
-
-    if (await exists(file)) {
-      const content = await fs.readFile(file);
-      return this.checkExpiry(cls, await ModelCrudUtil.load(cls, content));
-    }
-
-    throw new NotFoundError(cls, id);
-  }
-
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
-    if (!item.id) {
-      item.id = this.idSource.create();
-    }
-
-    const file = await this.#resolveName(cls, '.json', item.id);
-
-    if (await exists(file)) {
-      throw new ExistsError(cls, item.id!);
-    }
-
-    return await this.upsert(cls, item);
-  }
-
-  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
-    await this.get(cls, item.id);
-    return await this.upsert(cls, item);
-  }
-
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
-    ModelCrudUtil.ensureNotSubType(cls);
-    const prepped = await ModelCrudUtil.preStore(cls, item, this);
-
-    const file = await this.#resolveName(cls, '.json', item.id);
-    await fs.writeFile(file, JSON.stringify(item), { encoding: 'utf8' });
-
-    return prepped;
-  }
-
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T> {
-    ModelCrudUtil.ensureNotSubType(cls);
-    const id = item.id;
-    item = await ModelCrudUtil.naivePartialUpdate(cls, item, view, () => this.get(cls, id));
-    const file = await this.#resolveName(cls, '.json', item.id);
-    await fs.writeFile(file, JSON.stringify(item), { encoding: 'utf8' });
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return item as T;
-  }
-
-  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
-    const file = await this.#find(cls, '.json', id);
-    await fs.unlink(file);
-  }
-
-  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
-    for await (const [id] of FileModelService.scanFolder(await this.#resolveName(cls, '.json'), '.json')) {
-      try {
-        yield await this.get(cls, id);
-      } catch (err) {
-        if (!(err instanceof NotFoundError)) {
-          throw err;
-        }
-      }
-    }
-  }
-
-  // Stream
-  async upsertStream(location: string, input: Readable, meta: StreamMeta): Promise<void> {
-    const file = await this.#resolveName(STREAMS, BIN, location);
-    await Promise.all([
-      await pipeline(input, createWriteStream(file)),
-      fs.writeFile(file.replace(BIN, META), JSON.stringify(meta), 'utf8')
-    ]);
-  }
-
-  async getStream(location: string, range?: StreamRange): Promise<Readable> {
-    const file = await this.#find(STREAMS, BIN, location);
-    if (range) {
-      const meta = await this.describeStream(location);
-      range = enforceRange(range, meta.size);
-    }
-    return createReadStream(file, range);
-  }
-
-  async describeStream(location: string): Promise<StreamMeta> {
-    const file = await this.#find(STREAMS, META, location);
-    const content = await fs.readFile(file);
-    const text: StreamMeta = JSON.parse(content.toString('utf8'));
-    return text;
-  }
-
-  async deleteStream(location: string): Promise<void> {
-    const file = await this.#resolveName(STREAMS, BIN, location);
-    if (await exists(file)) {
-      await Promise.all([
-        fs.unlink(file),
-        fs.unlink(file.replace('.bin', META))
-      ]);
-    } else {
-      throw new NotFoundError('Stream', location);
-    }
-  }
-
-  // Expiry
-  async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> {
-    return ModelExpiryUtil.naiveDeleteExpired(this, cls);
-  }
-
-  // Storage management
-  async createStorage(): Promise<void> {
-    const dir = path.resolve(this.config.folder, this.config.namespace);
-    await fs.mkdir(dir, { recursive: true });
-  }
-
-  async deleteStorage(): Promise<void> {
-    await fs.rm(path.resolve(this.config.folder, this.config.namespace), { recursive: true, force: true });
-  }
-
-  async truncateModel(cls: Class<ModelType>): Promise<void> {
-    await fs.rm(await this.#resolveName(cls === StreamModel ? STREAMS : cls), { recursive: true, force: true });
-  }
-}