@toa.io/extensions.storages 1.0.0-alpha.21 → 1.0.0-alpha.219

package/source/providers/Temporary.ts

@@ -1,16 +1,15 @@
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { FileSystem } from './FileSystem'
-import type { ProviderSecrets } from '../Provider'
 
 export interface TemporaryOptions {
   directory: string
 }
 
 export class Temporary extends FileSystem {
-  public constructor (options: TemporaryOptions, secrets?: ProviderSecrets) {
+  public constructor (options: TemporaryOptions) {
     const path = join(tmpdir(), options.directory)
 
-    super({ path }, secrets)
+    super({ path })
   }
 }

package/source/providers/Test.ts

@@ -1,13 +1,13 @@
 import { Temporary, type TemporaryOptions } from './Temporary'
-import type { ProviderSecret, ProviderSecrets } from '../Provider'
+import type { Secret } from '../Secrets'
 
 export class Test extends Temporary {
-  public static override readonly SECRETS: readonly ProviderSecret[] = [
+  public static override readonly SECRETS: readonly Secret[] = [
     { name: 'USERNAME' },
     { name: 'PASSWORD' }
   ]
 
-  public constructor (options: TemporaryOptions, secrets?: ProviderSecrets) {
-    super(options, secrets)
+  public constructor (options: TemporaryOptions) {
+    super(options)
   }
 }

package/source/providers/index.test.ts

@@ -1,126 +1,152 @@
-import { type Readable } from 'node:stream'
-import { buffer } from 'node:stream/consumers'
-import { readFile } from 'node:fs/promises'
+import assert from 'node:assert'
 import { createReadStream } from 'node:fs'
-import path from 'node:path'
-import { randomUUID } from 'node:crypto'
+import { resolve } from 'node:path'
 import { suites } from '../test/util'
 import { providers } from './index'
-import type { ProviderConstructor } from '../Provider'
+import type { Constructor } from '../Provider'
+import type { Metadata, Stream } from '../Entry'
+
+const sample = resolve(__dirname, '../test/sample.jpeg')
+const lenna = resolve(__dirname, '../test/lenna.png')
+
+const metadata: Metadata = {
+  type: 'image/jpeg',
+  size: 73444,
+  checksum: 'd41d8cd98f00b204e9800998ecf8427e',
+  created: new Date().toISOString(),
+  attributes: {}
+}
 
 describe.each(suites)('$provider', (suite) => {
+  const id = Math.random().toString(36).substring(7)
   const it = suite.run ? global.it : global.it.skip
-  const Provider: ProviderConstructor = providers[suite.provider]
+  const Provider: Constructor = providers[suite.provider]
   const provider = new Provider(suite.options, suite.secrets)
 
-  let dir: string
+  describe('put, get, head', () => {
+    let entry: Stream
 
-  beforeAll(async () => {
-    process.chdir(path.resolve(__dirname, '../test/'))
-  })
+    beforeAll(async () => {
+      await provider.put(id, createReadStream(sample))
+      await provider.commit(id, metadata)
 
-  beforeEach(() => {
-    dir = '/' + randomUUID()
-  })
+      entry = await provider.get(id) as Stream
+    })
 
-  it('should be', async () => {
-    expect(provider).toBeInstanceOf(Provider)
-  })
+    afterAll(() => entry.stream.destroy())
 
-  it('should return null if file not found', async () => {
-    const result = await provider.get(randomUUID())
+    it('should create metadata', async () => {
+      expect(entry.size).toEqual(metadata.size)
+    })
 
-    expect(result).toBeNull()
-  })
+    if (suite.provider !== 'cloudinary')
+      it('should store attributes', async () => {
+        const path = '/path/to/file'
 
-  it('should create entry', async () => {
-    const stream = createReadStream('lenna.png')
+        await provider.put(path, createReadStream(sample))
+        await provider.commit(path, { ...metadata, attributes: { foo: 'bar' } })
 
-    await provider.put(dir, 'lenna.png', stream)
+        const entry = await provider.get(path) as Stream
 
-    const readable = await provider.get(dir + '/lenna.png') as Readable
-    const output = await buffer(readable)
-    const lenna = await readFile('lenna.png')
+        expect(entry.attributes).toEqual({ foo: 'bar' })
 
-    expect(output.compare(lenna)).toBe(0)
-  })
+        entry.stream.destroy()
+      })
 
-  it('should overwrite existing entry', async () => {
-    const stream0 = createReadStream('lenna.png')
-    const stream1 = createReadStream('albert.jpg')
+    it('should overwrite', async () => {
+      const path = Math.random().toString(36).substring(7)
 
-    await provider.put(dir, 'lenna.png', stream0)
-    await provider.put(dir, 'lenna.png', stream1)
+      await provider.put(path, createReadStream(sample))
+      await provider.commit(path, metadata)
 
-    const readable = await provider.get(dir + '/lenna.png') as Readable
-    const output = await buffer(readable)
-    const albert = await readFile('albert.jpg')
+      if (suite.provider === 'cloudinary')
+        await new Promise((resolve) => setTimeout(resolve, 5_000))
 
-    expect(output.compare(albert)).toBe(0)
-  })
+      await expect(provider.put(path, createReadStream(lenna)))
+        .resolves.not.toThrow()
 
-  it('should get by path', async () => {
-    const stream = createReadStream('lenna.png')
+      const meta = { ...metadata, size: 473831 } // lenna size
 
-    await provider.put(dir, 'lenna.png', stream)
+      await provider.commit(path, meta)
 
-    const result = await provider.get('/bar/lenna.png')
+      if (suite.provider === 'cloudinary')
+        await new Promise((resolve) => setTimeout(resolve, 10_000))
 
-    expect(result).toBeNull()
-  })
+      const overwritten = await provider.get(path) as Stream
 
-  describe('danger', () => {
-    /*
+      expect(overwritten.size).toEqual(meta.size)
 
-    WHEN MAKING CHANGES TO DELETION,
-    ALWAYS RUN TESTS IN STEP-BY-STEP DEBUGGING MODE
+      overwritten.stream.destroy()
+    })
 
-    YOU MAY EVENTUALLY DELETE YOUR ENTIRE FILE SYSTEM
+    it('should return error if not found', async () => {
+      const error = await provider.get(Math.random().toString(36).substring(7)) as any
 
-                              Sincerely yours, Murphy
+      expect(error).toBeInstanceOf(Error)
+      expect(error.code).toBe('NOT_FOUND')
+    })
+
+    it('should return entry', async () => {
+      const entry = await provider.head(id)
+
+      assert.ok(!(entry instanceof Error))
 
-     */
+      expect(entry.size).toEqual(metadata.size)
+    })
+  })
 
-    it('should delete entry', async () => {
-      const stream = createReadStream('lenna.png')
+  describe('delete', () => {
+    const path = '/path/to/' + Math.random().toString(36).substring(7)
 
-      await provider.put(dir, 'lenna.png', stream)
-      await provider.delete(dir + '/lenna.png')
+    it('should remove file', async () => {
+      await provider.put(path, createReadStream(sample))
+      await provider.commit(path, metadata)
+      await provider.delete(path)
 
-      const result = await provider.get(dir + '/lenna.png')
+      const error = await provider.get(path) as any
 
-      expect(result).toBeNull()
+      expect(error).toBeInstanceOf(Error)
+      expect(error.code).toBe('NOT_FOUND')
     })
 
-    it('should not throw if path does not exists', async () => {
-      await expect(provider.delete(dir + '/whatever')).resolves.not.toThrow()
+    it('should not return error if not found', async () => {
+      const empty = await provider.delete(Math.random().toString(36).substring(7))
+
+      expect(empty).toBeUndefined()
     })
+  })
 
-    it('should delete directory', async () => {
-      const stream = createReadStream('lenna.png')
+  describe('move', () => {
+    it.each([true, false])('should move (commit: %s)', async (committed) => {
+      const from = Math.random().toString(36).substring(7)
+      const to = Math.random().toString(36).substring(7)
 
-      await provider.put(dir, 'lenna.png', stream)
-      await provider.delete(dir)
+      await provider.put(from, createReadStream(sample))
 
-      const result = await provider.get(dir + '/lenna.png')
+      if (committed)
+        await provider.commit(from, metadata)
 
-      expect(result).toBeNull()
-    })
+      await provider.move(from, to)
 
-    it('should move an entry', async () => {
-      const stream = createReadStream('lenna.png')
-      const dir2 = '/' + randomUUID()
+      if (!committed)
+        await provider.commit(to, metadata)
 
-      await provider.put(dir, 'lenna.png', stream)
-      await provider.move(dir + '/lenna.png', dir2 + '/lenna2.png')
+      const error = await provider.get(from) as any
 
-      const result = await provider.get(dir2 + '/lenna2.png') as Readable
+      expect(error).toBeInstanceOf(Error)
 
-      expect(result).not.toBeNull()
+      const entry = await provider.get(to) as Stream
 
-      const nope = await provider.get(dir + '/lenna.png')
+      expect(entry.stream).toBeDefined()
+    })
 
-      expect(nope).toBeNull()
+    it('should return error if not found', async () => {
+      const error = await provider.move(Math.random().toString(36).substring(7), 'whatever') as any
+
+      expect(error).toBeInstanceOf(Error)
+      expect(error.code).toBe('NOT_FOUND')
     })
   })
 })
+
+jest.setTimeout(30_000)

package/source/providers/index.ts

@@ -1,16 +1,22 @@
 import { FileSystem } from './FileSystem'
 import { S3 } from './S3'
+import { Cloudinary } from './Cloudinary'
 import { Temporary } from './Temporary'
 import { Test } from './Test'
-import { InMemory } from './Memory'
-import type { ProviderConstructor } from '../Provider'
+import type { Constructor } from '../Provider'
 
 export const providers = {
   s3: S3,
+  cloudinary: Cloudinary,
   fs: FileSystem,
   tmp: Temporary,
-  mem: InMemory,
   test: Test
-} as const satisfies Record<string, ProviderConstructor>
+} as const satisfies Record<string, Constructor>
 
 export type { Declaration } from './Declaration'
+
+export type { S3Options } from './S3'
+export type { CloudinaryOptions } from './Cloudinary'
+export type { FileSystemOptions } from './FileSystem'
+export type { TemporaryOptions } from './Temporary'
+export type { FileSystem, S3, Cloudinary, Temporary }

package/source/schemas.ts

@@ -9,6 +9,7 @@ const ns = namespace(path)
 
 export const annotation: Schema<Annotation> = ns.schema<Annotation>('annotation')
 export const s3: Schema<Declaration> = ns.schema<Declaration>('s3')
+export const cloudinary: Schema<Declaration> = ns.schema<Declaration>('cloudinary')
 export const fs: Schema<Declaration> = ns.schema<Declaration>('fs')
 export const mem: Schema<Declaration> = ns.schema<Declaration>('mem')
 export const tmp: Schema<Declaration> = ns.schema<Declaration>('tmp')

package/source/test/.env.example

@@ -1 +1,5 @@
 RUN_S3=1
+RUN_CLOUDINARY=1
+
+CLOUDINARY_API_KEY=cloudinary_api_key
+CLOUDINARY_API_SECRET=cloudinary_api_secret

package/source/test/util.ts

@@ -1,10 +1,13 @@
 import { join } from 'node:path'
 import dotenv from 'dotenv'
-import type { ProviderSecrets } from '../Provider'
-import type { providers } from '../providers'
-import type { FileSystemOptions } from '../providers/FileSystem'
-import type { S3Options } from '../providers/S3'
-import type { TemporaryOptions } from '../providers/Temporary'
+import type { Secrets } from '../Secrets'
+import type {
+  providers,
+  S3Options,
+  CloudinaryOptions,
+  FileSystemOptions,
+  TemporaryOptions
+} from '../providers'
 
 dotenv.config({ path: join(__dirname, '.env') })
 
@@ -16,10 +19,6 @@ export const suites = [
       directory: 'toa-storages-temp'
     }
   },
-  {
-    run: true,
-    provider: 'mem'
-  },
   {
     run: process.env.RUN_S3 === '1',
     provider: 's3',
@@ -32,14 +31,65 @@ export const suites = [
       ACCESS_KEY_ID: 'developer',
       SECRET_ACCESS_KEY: 'secret'
     }
+  },
+  {
+    run: process.env.RUN_CLOUDINARY === '1',
+    provider: 'cloudinary',
+    options: {
+      environment: 'dl5z4zgth',
+      type: 'image',
+      prefix: 'toa-dev',
+      transformations: [
+        {
+          extension: '(?<width>\\d*)x(?<height>\\d*)(z(?<zoom>\\d*))?',
+          transformation: {
+            width: '<width>',
+            height: '<height>',
+            zoom: '<zoom>',
+            crop: 'thumb',
+            gravity: 'face'
+          },
+          optional: true
+        },
+        {
+          extension: '\\[(?<width>\\d*)x(?<height>\\d*)\\](z(?<zoom>\\d+))?',
+          transformation: {
+            width: '<width>',
+            height: '<height>',
+            zoom: '<zoom>',
+            crop: 'fit'
+          },
+          optional: true
+        },
+        {
+          extension: 'vertical',
+          condition: 'w_gt_h',
+          transformation: {
+            angle: 90
+          },
+          optional: true
+        },
+        {
+          extension: '(?<format>jpeg|webp)',
+          transformation: {
+            fetch_format: '<format>'
+          },
+          optional: true
+        }
+      ]
+    },
+    secrets: {
+      API_KEY: process.env.CLOUDINARY_API_KEY ?? '',
+      API_SECRET: process.env.CLOUDINARY_API_SECRET ?? ''
+    }
   }
   // add more providers here, use `run` as a condition to run the test
   // e.g.: `run: process.env.ACCESS_KEY_ID !== undefined`
 ] satisfies Suite[]
 
-interface Suite {
+export interface Suite {
   run: boolean
   provider: keyof typeof providers
-  options?: FileSystemOptions | S3Options | TemporaryOptions
-  secrets?: ProviderSecrets
+  options?: S3Options | CloudinaryOptions | FileSystemOptions | TemporaryOptions
+  secrets?: Secrets
 }

package/transpiled/Entry.d.ts

@@ -1,14 +1,18 @@
-export interface Entry {
+/// <reference types="node" />
+import type { Readable } from 'node:stream';
+export type Entry = {
     id: string;
-    size: number;
+} & Metadata;
+export type Stream = {
+    stream: Readable;
+} & Metadata;
+export interface Metadata {
     type: string;
-    created: number;
-    variants: Variant[];
-    meta: Record<string, unknown>;
+    size: number | null;
+    checksum: string;
+    created: string;
+    attributes: Attributes;
+    range?: string;
+    partial?: boolean;
 }
-interface Variant {
-    name: string;
-    size: number;
-    type: string;
-}
-export {};
+export type Attributes = Record<string, string>;

package/transpiled/Factory.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Factory = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
+const openspan_1 = require("openspan");
 const generic_1 = require("@toa.io/generic");
 const providers_1 = require("./providers");
 const Storage_1 = require("./Storage");
@@ -14,8 +15,8 @@ const Annotation_1 = require("./Annotation");
 class Factory {
     annotation;
     constructor() {
-        const env = process.env.TOA_STORAGES;
-        node_assert_1.default.ok(env !== undefined, 'TOA_STORAGES is not defined');
+        const env = process.env[deployment_1.ENV_PREFIX];
+        node_assert_1.default.ok(env !== undefined, `${deployment_1.ENV_PREFIX} is not defined`);
         this.annotation = (0, generic_1.decode)(env);
         (0, Annotation_1.validateAnnotation)(this.annotation);
     }
@@ -30,10 +31,15 @@ class Factory {
         return storages;
     }
     createStorage(name, declaration) {
-        const { provider: providerId, ...options } = declaration;
-        const Provider = providers_1.providers[providerId];
+        const { provider: id, ...options } = declaration;
+        const Provider = providers_1.providers[id];
         const secrets = this.resolveSecrets(name, Provider);
         const provider = new Provider(options, secrets);
+        openspan_1.console.debug('Storage created', {
+            name,
+            provider: id,
+            ...(provider.root === undefined ? undefined : { root: provider.root })
+        });
         return new Storage_1.Storage(provider);
     }
     resolveSecrets(storageName, Class) {
@@ -41,7 +47,7 @@ class Factory {
             return {};
         const secrets = {};
         for (const secret of Class.SECRETS) {
-            const variable = `${deployment_1.SERIALIZATION_PREFIX}_${storageName}_${secret.name}`.toUpperCase();
+            const variable = `${deployment_1.ENV_PREFIX}_${storageName}_${secret.name}`.toUpperCase();
             const value = process.env[variable];
             node_assert_1.default.ok(secret.optional === true || value !== undefined, `'${variable}' is not defined`);
             secrets[secret.name] = value;

package/transpiled/Factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"Factory.js","sourceRoot":"","sources":["../source/Factory.ts"],"names":[],"mappings":";;;;;;AAAA,8DAAgC;AAChC,6CAAwC;AACxC,2CAAuC;AACvC,uCAAkD;AAClD,qCAAiC;AACjC,6CAAmD;AACnD,6CAAiD;AAKjD,MAAa,OAAO;IACD,UAAU,CAAY;IAEvC;QACE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAA;QAEpC,qBAAM,CAAC,EAAE,CAAC,GAAG,KAAK,SAAS,EAAE,6BAA6B,CAAC,CAAA;QAE3D,IAAI,CAAC,UAAU,GAAG,IAAA,gBAAM,EAAC,GAAG,CAAC,CAAA;QAE7B,IAAA,+BAAkB,EAAC,IAAI,CAAC,UAAU,CAAC,CAAA;IACrC,CAAC;IAEM,MAAM;QACX,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QAEtC,OAAO,IAAI,eAAM,CAAC,QAAQ,CAAC,CAAA;IAC7B,CAAC;IAEO,cAAc;QACpB,MAAM,QAAQ,GAAa,EAAE,CAAA;QAE7B,KAAK,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC;YAC/D,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,WAAW,CAAC,CAAA;QAExD,OAAO,QAAQ,CAAA;IACjB,CAAC;IAEO,aAAa,CAAE,IAAY,EAAE,WAAwB;QAC3D,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,GAAG,WAAW,CAAA;QACxD,MAAM,QAAQ,GAAwB,qBAAS,CAAC,UAAU,CAAC,CAAA;QAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;QACnD,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAE/C,OAAO,IAAI,iBAAO,CAAC,QAAQ,CAAC,CAAA;IAC9B,CAAC;IAEO,cAAc,CAAE,WAAmB,EACzC,KAA0B;QAC1B,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAC7B,OAAO,EAAE,CAAA;QAEX,MAAM,OAAO,GAAuC,EAAE,CAAA;QAEtD,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACnC,MAAM,QAAQ,GAAG,GAAG,iCAAoB,IAAI,WAAW,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;YACtF,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YAEnC,qBAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EACvD,IAAI,QAAQ,kBAAkB,CAAC,CAAA;YAEjC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;QAC9B,CAAC;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;CACF;AAxDD,0BAwDC"}
+{"version":3,"file":"Factory.js","sourceRoot":"","sources":["../source/Factory.ts"],"names":[],"mappings":";;;;;;AAAA,8DAAgC;AAChC,uCAAkC;AAClC,6CAAwC;AACxC,2CAAuC;AACvC,uCAAkD;AAClD,qCAAiC;AACjC,6CAAyC;AACzC,6CAAiD;AAMjD,MAAa,OAAO;IACD,UAAU,CAAY;IAEvC;QACE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAU,CAAC,CAAA;QAEnC,qBAAM,CAAC,EAAE,CAAC,GAAG,KAAK,SAAS,EAAE,GAAG,uBAAU,iBAAiB,CAAC,CAAA;QAE5D,IAAI,CAAC,UAAU,GAAG,IAAA,gBAAM,EAAC,GAAG,CAAC,CAAA;QAE7B,IAAA,+BAAkB,EAAC,IAAI,CAAC,UAAU,CAAC,CAAA;IACrC,CAAC;IAEM,MAAM;QACX,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,EAAE,CAAA;QAEtC,OAAO,IAAI,eAAM,CAAC,QAAQ,CAAC,CAAA;IAC7B,CAAC;IAEO,cAAc;QACpB,MAAM,QAAQ,GAAa,EAAE,CAAA;QAE7B,KAAK,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC;YAC/D,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,WAAW,CAAC,CAAA;QAExD,OAAO,QAAQ,CAAA;IACjB,CAAC;IAEO,aAAa,CAAE,IAAY,EAAE,WAAwB;QAC3D,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,OAAO,EAAE,GAAG,WAAW,CAAA;QAChD,MAAM,QAAQ,GAAgB,qBAAS,CAAC,EAAE,CAAC,CAAA;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;QACnD,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAE/C,kBAAO,CAAC,KAAK,CAAC,iBAAiB,EAAE;YAC/B,IAAI;YACJ,QAAQ,EAAE,EAAE;YACZ,GAAG,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC;SACvE,CAAC,CAAA;QAEF,OAAO,IAAI,iBAAO,CAAC,QAAQ,CAAC,CAAA;IAC9B,CAAC;IAEO,cAAc,CAAE,WAAmB,EAAE,KAAkB;QAC7D,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAC7B,OAAO,EAAE,CAAA;QAEX,MAAM,OAAO,GAAuC,EAAE,CAAA;QAEtD,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACnC,MAAM,QAAQ,GAAG,GAAG,uBAAU,IAAI,WAAW,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;YAC5E,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YAEnC,qBAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EACvD,IAAI,QAAQ,kBAAkB,CAAC,CAAA;YAEjC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;QAC9B,CAAC;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;CACF;AA7DD,0BA6DC"}

package/transpiled/Provider.d.ts

@@ -1,20 +1,21 @@
 /// <reference types="node" />
-import { type Readable } from 'node:stream';
-export type ProviderSecrets<K extends string = string> = Record<K | string, string | undefined>;
-export interface ProviderSecret {
-    readonly name: string;
-    readonly optional?: boolean;
-}
-export declare abstract class Provider<Options = void> {
-    static readonly SECRETS: readonly ProviderSecret[];
-    constructor(_: Options, secrets?: ProviderSecrets);
-    abstract get(path: string): Promise<Readable | null>;
-    abstract put(path: string, filename: string, stream: Readable): Promise<void>;
+import type { Metadata, Stream } from './Entry';
+import type { Readable } from 'node:stream';
+import type { Maybe } from '@toa.io/types';
+import type { Secret, Secrets } from './Secrets';
+export declare abstract class Provider<Options = unknown> {
+    static readonly SECRETS?: readonly Secret[];
+    readonly root?: string;
+    readonly options: Options;
+    protected constructor(options: Options, secrets?: Secrets);
+    abstract get(path: string, options?: unknown): Promise<Maybe<Stream>>;
+    abstract head(path: string): Promise<Maybe<Metadata>>;
+    abstract put(path: string, stream: Readable): Promise<void>;
+    abstract commit(path: string, metadata: Metadata): Promise<void>;
     abstract delete(path: string): Promise<void>;
-    abstract move(from: string, to: string): Promise<void>;
+    abstract move(from: string, to: string): Promise<Maybe<void>>;
 }
-export interface ProviderConstructor {
-    readonly SECRETS: readonly ProviderSecret[];
-    prototype: Provider;
-    new (options: any, secrets?: ProviderSecrets): Provider;
+export interface Constructor<Options = any> {
+    SECRETS?: readonly Secret[];
+    new (options: Options, secrets?: Secrets): Provider<Options>;
 }

package/transpiled/Provider.js

@@ -26,10 +26,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Provider = void 0;
 const assert = __importStar(require("node:assert"));
 class Provider {
-    static SECRETS = [];
-    constructor(_, secrets) {
-        for (const { name, optional = false } of new.target.SECRETS)
-            assert.ok(optional || secrets?.[name] !== undefined, `Missing secret '${name}'`);
+    static SECRETS;
+    root;
+    options;
+    constructor(options, secrets) {
+        this.options = options;
+        new.target.SECRETS?.forEach(({ name, optional }) => assert.ok(optional === true || secrets?.[name] !== undefined, `Missing secret '${name}'`));
     }
 }
 exports.Provider = Provider;

package/transpiled/Provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"Provider.js","sourceRoot":"","sources":["../source/Provider.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,oDAAqC;AASrC,MAAsB,QAAQ;IACrB,MAAM,CAAU,OAAO,GAA8B,EAAE,CAAA;IAE9D,YAAoB,CAAU,EAAE,OAAyB;QACvD,KAAK,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,KAAK,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO;YACzD,MAAM,CAAC,EAAE,CAAC,QAAQ,IAAI,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,SAAS,EAAE,mBAAmB,IAAI,GAAG,CAAC,CAAA;IACpF,CAAC;;AANH,4BAeC"}
+{"version":3,"file":"Provider.js","sourceRoot":"","sources":["../source/Provider.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oDAAqC;AAMrC,MAAsB,QAAQ;IACrB,MAAM,CAAU,OAAO,CAAoB;IAClC,IAAI,CAAS;IACb,OAAO,CAAS;IAEhC,YAAuB,OAAgB,EAAE,OAAiB;QACxD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QAEtB,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CACjD,MAAM,CAAC,EAAE,CAAC,QAAQ,KAAK,IAAI,IAAI,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,SAAS,EAAE,mBAAmB,IAAI,GAAG,CAAC,CAAC,CAAA;IAC9F,CAAC;CAaF;AAvBD,4BAuBC"}

package/transpiled/Scanner.d.ts

@@ -1,15 +1,17 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { PassThrough, type TransformCallback } from 'node:stream';
 export declare class Scanner extends PassThrough {
     size: number;
     type: string;
-    error: Error | null;
+    error?: Error;
     private readonly hash;
     private readonly claim?;
     private readonly accept?;
+    private readonly limit?;
     private position;
-    private detected;
+    private completed;
     private readonly chunks;
     constructor(control?: ScanOptions);
     digest(): string;
@@ -18,9 +20,11 @@ export declare class Scanner extends PassThrough {
     private complete;
     private verify;
     private match;
+    private negotiate;
     private interrupt;
 }
 export interface ScanOptions {
     claim?: string;
     accept?: string;
+    limit?: number;
 }