@toa.io/extensions.storages 1.0.0-alpha.274 → 1.0.0-alpha.277

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.0.0-alpha.277](https://github.com/toa-io/toa/compare/v1.0.0-alpha.276...v1.0.0-alpha.277) (2026-09-03)
+
+### Bug Fixes
+
+* drop the build output that landed beside the sources ([a724f69](https://github.com/toa-io/toa/commit/a724f6921190e5c9d945e33c6035bb12d832e5c8))
+
+
 # [1.0.0-alpha.274](https://github.com/toa-io/toa/compare/v1.0.0-alpha.273...v1.0.0-alpha.274) (2026-09-02)
 
 **Note:** Version bump only for package @toa.io/extensions.storages

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@toa.io/extensions.storages",
-  "version": "1.0.0-alpha.274",
+  "version": "1.0.0-alpha.277",
+  "type": "module",
   "description": "Toa Storages",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -16,24 +17,20 @@
   "publishConfig": {
     "access": "public"
   },
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node"
-  },
   "scripts": {
-    "test": "jest",
+    "test": "echo \"Error: run tests from root\" && exit 1",
     "transpile": "npx tsc"
   },
   "devDependencies": {
     "dotenv": "17.4.2"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.1123.0",
-    "@aws-sdk/lib-storage": "3.1123.0",
-    "@toa.io/schemas": "1.0.0-alpha.274",
+    "@aws-sdk/client-s3": "3.1125.0",
+    "@aws-sdk/lib-storage": "3.1125.0",
+    "@toa.io/schemas": "1.0.0-alpha.277",
     "cloudinary": "2.11.0",
     "negotiator": "1.1.0",
-    "openspan": "1.0.0-alpha.272"
+    "openspan": "1.0.0-alpha.277"
   },
-  "gitHead": "7df32eb2872155c45681c299036b1efbeefd6518"
+  "gitHead": "0c0071418c2c56a44e621ba5ced5cdd23dff1738"
 }

package/source/Annotation.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert'
-import { providers } from './providers'
-import * as schemas from './schemas'
-import type { Declaration } from './providers'
+import { providers } from './providers/index.js'
+import * as schemas from './schemas.js'
+import type { Declaration } from './providers/index.js'
 import type { Schema } from '@toa.io/schemas'
 
 export type Annotation = Record<string, Declaration>

package/source/Aspect.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert'
 import { Connector, type extensions } from '@toa.io/core'
-import { type Storage, type Storages } from './Storage'
+import { type Storage, type Storages } from './Storage.js'
 
 export class Aspect extends Connector implements extensions.Aspect {
   public readonly name = 'storages'

package/source/Factory.ts

@@ -1,14 +1,14 @@
 import assert from 'node:assert'
 import { console } from 'openspan'
-import { providers } from './providers'
-import { Storage, type Storages } from './Storage'
-import { Aspect } from './Aspect'
-import { ENV_PREFIX } from './deployment'
-import { validateAnnotation } from './Annotation'
-import type { Constructor } from './Provider'
-import type { Declaration } from './providers'
-import type { Annotation } from './Annotation'
-import type { Secrets } from './Secrets'
+import { providers } from './providers/index.js'
+import { Storage, type Storages } from './Storage.js'
+import { Aspect } from './Aspect.js'
+import { ENV_PREFIX } from './deployment.js'
+import { validateAnnotation } from './Annotation.js'
+import type { Constructor } from './Provider.js'
+import type { Declaration } from './providers/index.js'
+import type { Annotation } from './Annotation.js'
+import type { Secrets } from './Secrets.js'
 
 export class Factory {
   private readonly annotation: Annotation

package/source/Provider.ts

@@ -1,8 +1,8 @@
 import * as assert from 'node:assert'
-import type { Metadata, Stream } from './Entry'
+import type { Metadata, Stream } from './Entry.js'
 import type { Readable } from 'node:stream'
 import type { Maybe } from '@toa.io/types'
-import type { Secret, Secrets } from './Secrets'
+import type { Secret, Secrets } from './Secrets.js'
 
 export abstract class Provider<Options = unknown> {
   public static readonly SECRETS?: readonly Secret[]

package/source/Storage.test.ts

@@ -1,15 +1,15 @@
+import { describe, it, before, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+
 import { randomUUID } from 'node:crypto'
 import { buffer } from 'node:stream/consumers'
 import { createReadStream } from 'node:fs'
 import path from 'node:path'
-import assert from 'node:assert'
-import { Storage } from './Storage'
-import { suites } from './test/util'
-import { providers } from './providers'
-import type { Entry, Metadata, Stream } from './Entry'
-import type { Constructor } from './Provider'
-
-jest.setTimeout(15_000)
+import { Storage } from './Storage.js'
+import { suites } from './test/util.js'
+import { providers } from './providers/index.js'
+import type { Entry, Stream } from './Entry.js'
+import type { Constructor } from './Provider.js'
 
 const suite = suites[0]
 const Provider: Constructor = providers[suite.provider]
@@ -17,19 +17,19 @@ const provider = new Provider(suite.options, suite.secrets)
 const storage = new Storage(provider)
 const dir = '/' + randomUUID()
 
-beforeAll(async () => {
-  process.chdir(path.join(__dirname, 'test'))
+before(async () => {
+  process.chdir(path.join(import.meta.dirname, 'test'))
 })
 
 it('should be', async () => {
-  expect(storage).toBeInstanceOf(Storage)
+  assert.ok(storage instanceof Storage)
 })
 
 it('should return error if entry is not found', async () => {
   const result = await storage.get('not-found')
 
-  expect(result).toBeInstanceOf(Error)
-  expect(result).toMatchObject({ code: 'NOT_FOUND' })
+  assert.ok(result instanceof Error)
+  assert.deepStrictEqual(result.code, 'NOT_FOUND')
 })
 
 describe('put', () => {
@@ -48,43 +48,43 @@ describe('put', () => {
   })
 
   it('should not return error', async () => {
-    expect(lenna).not.toBeInstanceOf(Error)
+    assert.ok(!(lenna instanceof Error))
   })
 
   it('should return entry id', async () => {
-    expect(lenna.id).toBeDefined()
-    expect(lenna.id).toHaveLength(32)
+    assert.notStrictEqual(lenna.id, undefined)
+    assert.strictEqual(lenna.id.length, 32)
   })
 
   it('should detect file type', async () => {
-    expect(lenna).toHaveProperty('type', 'image/png')
+    assert.deepStrictEqual(lenna['type'], 'image/png')
   })
 
   it('should count size', async () => {
-    expect(lenna).toHaveProperty('size', 473831)
+    assert.deepStrictEqual(lenna['size'], 473831)
   })
 
   it('should return entry', async () => {
-    expect(lenna).toMatchObject({
+    assert.partialDeepStrictEqual(lenna, {
       id: lenna.id,
       type: 'image/png',
       size: 473831,
       checksum: lenna.checksum,
-      created: expect.any(String),
       attributes: {}
-    } satisfies Entry)
+    })
+    assert.strictEqual(typeof lenna.created, 'string')
   })
 
   it('should create metadata', async () => {
     const entry = await storage.head(path) as Entry
 
-    expect(entry).toMatchObject({
+    assert.partialDeepStrictEqual(entry, {
       type: 'image/png',
       size: 473831,
       checksum: lenna.checksum,
-      created: expect.any(String),
       attributes: {}
-    } satisfies Metadata)
+    })
+    assert.strictEqual(typeof entry.created, 'string')
   })
 
   it('should set timestamp', async () => {
@@ -92,8 +92,8 @@ describe('put', () => {
     const entry = await storage.get(path) as Stream
     const created = new Date(entry.created).getTime()
 
-    expect(created).toBeLessThanOrEqual(now)
-    expect(created).toBeGreaterThanOrEqual(startCreation)
+    assert.ok(created <= now)
+    assert.ok(created >= startCreation)
   })
 
   it('should store with given id', async () => {
@@ -102,14 +102,14 @@ describe('put', () => {
 
     const entry = await storage.put(dir, stream, { id }) as Entry
 
-    expect(entry.id).toBe(id)
+    assert.strictEqual(entry.id, id)
 
     const check = await storage.head(`${dir}/${id}`)
 
     if (check instanceof Error)
       throw check
 
-    expect(check.id).toBe(id)
+    assert.strictEqual(check.id, id)
   })
 })
 
@@ -130,32 +130,32 @@ describe('get, head', () => {
     const stored = await buffer(entry.stream)
     const buf = await buffer(createReadStream('lenna.png'))
 
-    expect(stored.compare(new Uint8Array(buf.buffer))).toBe(0)
+    assert.strictEqual(stored.compare(new Uint8Array(buf.buffer)), 0)
   })
 
   it('should get entry', async () => {
     const entry = await storage.head(path) as Entry
 
-    expect(entry.id).toBe(lenna.id)
+    assert.strictEqual(entry.id, lenna.id)
   })
 
   if (suite.provider === 'cloudinary') {
     it('should return cloudinary url', async () => {
       const entry = await storage.head(`${path}.jpeg`) as Entry
 
-      expect(entry.attributes.url).toMatch(/^https:\/\//)
+      assert.match(entry.attributes.url, /^https:\/\//)
     })
 
     it('should support conditions', async () => {
       const entry = await storage.head(`${path}.vertical.jpeg`) as Entry
 
-      expect(entry.attributes.url.includes('/if_w_gt_h/a_90/if_end/')).toBe(true)
+      assert.strictEqual(entry.attributes.url.includes('/if_w_gt_h/a_90/if_end/'), true)
     })
 
     it('should return entry id when requested with extensions', async () => {
       const entry = await storage.head(`${path}.jpeg`) as Entry
 
-      expect(entry.id).toBe(lenna.id)
+      assert.strictEqual(entry.id, lenna.id)
     })
   }
 })
@@ -178,47 +178,47 @@ describe('delete', () => {
 
     const result = await storage.get(`${dir}/${lenna.id}`)
 
-    expect(result).toBeInstanceOf(Error)
-    expect(result).toHaveProperty('code', 'NOT_FOUND')
+    assert.ok(result instanceof Error)
+    assert.deepStrictEqual(result['code'], 'NOT_FOUND')
   })
 
   it('should not return error', async () => {
     const result = await storage.delete(dir)
 
-    expect(result).toBeUndefined()
+    assert.strictEqual(result, undefined)
   })
 })
 
 describe('signatures', () => {
-  it.each(['jpeg', 'gif', 'webp', 'heic', 'jxl', 'avif'])('should detect image/%s',
-    async (type) => {
+  for (const type of ['jpeg', 'gif', 'webp', 'heic', 'jxl', 'avif'])
+    it(`should detect image/${type}`, async () => {
       const stream = createReadStream('sample.' + type)
       const entry = await storage.put(dir, stream) as Entry
 
-      expect(entry).toHaveProperty('type', 'image/' + type)
+      assert.deepStrictEqual(entry['type'], 'image/' + type)
     })
 
-  it.each(['avi'])('should detect video/%s',
-    async (type) => {
+  for (const type of ['avi'])
+     it(`should detect video/${type}`, async () => {
       const stream = createReadStream('sample.' + type)
       const entry = await storage.put(dir, stream) as Entry
 
-      expect(entry).toHaveProperty('type', 'video/' + type)
+      assert.deepStrictEqual(entry['type'], 'video/' + type)
     })
 
-  it.each(['wav'])('should detect audio/%s',
-    async (type) => {
+  for (const type of ['wav'])
+     it(`should detect audio/${type}`, async () => {
       const stream = createReadStream('sample.' + type)
       const entry = (await storage.put(dir, stream)) as Entry
 
-      expect(entry).toHaveProperty('type', 'audio/' + type)
+      assert.deepStrictEqual(entry['type'], 'audio/' + type)
     })
 
   it('should be ok with Arny', async () => {
     const stream = createReadStream('arny.jpg')
     const entry = (await storage.put(dir, stream)) as Entry
 
-    expect(entry).toHaveProperty('type', 'image/jpeg')
+    assert.deepStrictEqual(entry['type'], 'image/jpeg')
   })
 })
 
@@ -227,8 +227,8 @@ it('should return error if type doesn\'t match', async () => {
 
   const result = await storage.put(dir, stream, { claim: 'image/png' })
 
-  expect(result).toBeInstanceOf(Error)
-  expect(result).toHaveProperty('code', 'TYPE_MISMATCH')
+  assert.ok(result instanceof Error)
+  assert.deepStrictEqual(result['code'], 'TYPE_MISMATCH')
 })
 
 it('should trust unknown types', async () => {
@@ -236,8 +236,8 @@ it('should trust unknown types', async () => {
 
   const result = await storage.put(dir, stream, { claim: 'text/plain' })
 
-  expect(result).not.toBeInstanceOf(Error)
-  expect(result).toHaveProperty('type', 'text/plain')
+  assert.ok(!(result instanceof Error))
+  assert.deepStrictEqual(result['type'], 'text/plain')
 })
 
 it('should return error if type is identifiable', async () => {
@@ -245,8 +245,8 @@ it('should return error if type is identifiable', async () => {
 
   const result = await storage.put(dir, stream, { claim: 'image/jpeg' })
 
-  expect(result).toBeInstanceOf(Error)
-  expect(result).toHaveProperty('code', 'TYPE_MISMATCH')
+  assert.ok(result instanceof Error)
+  assert.deepStrictEqual(result['code'], 'TYPE_MISMATCH')
 })
 
 it('should not return error if type application/octet-stream', async () => {
@@ -254,8 +254,8 @@ it('should not return error if type application/octet-stream', async () => {
 
   const result = await storage.put(dir, stream, { claim: 'application/octet-stream' })
 
-  expect(result).not.toBeInstanceOf(Error)
-  expect(result).toHaveProperty('type', 'image/jpeg')
+  assert.ok(!(result instanceof Error))
+  assert.deepStrictEqual(result['type'], 'image/jpeg')
 })
 
 it('should return error if type is not acceptable', async () => {
@@ -263,8 +263,8 @@ it('should return error if type is not acceptable', async () => {
 
   const result = await storage.put(dir, stream, { accept: 'image/png' })
 
-  expect(result).toBeInstanceOf(Error)
-  expect(result).toHaveProperty('code', 'NOT_ACCEPTABLE')
+  assert.ok(result instanceof Error)
+  assert.deepStrictEqual(result['code'], 'NOT_ACCEPTABLE')
 })
 
 it('should accept wildcard types', async () => {
@@ -272,27 +272,27 @@ it('should accept wildcard types', async () => {
 
   const result = await storage.put(dir, stream, { accept: 'image/*' })
 
-  expect(result).not.toBeInstanceOf(Error)
-  expect(result).toHaveProperty('type', 'image/jpeg')
+  assert.ok(!(result instanceof Error))
+  assert.deepStrictEqual(result['type'], 'image/jpeg')
 })
 
 it('should handle root entries', async () => {
   const stream = createReadStream('sample.jpeg')
   const result = await storage.put('/', stream) as Entry
 
-  expect(result).not.toBeInstanceOf(Error)
+  assert.ok(!(result instanceof Error))
 
   const stored = await storage.get(result.id)
 
-  expect(stored).not.toBeInstanceOf(Error)
+  assert.ok(!(stored instanceof Error))
 })
 
 it('should return error of stream size limit exceeded', async () => {
   const stream = createReadStream('sample.jpeg')
   const result = await storage.put(dir, stream, { limit: 1024 })
 
-  expect(result).toBeInstanceOf(Error)
-  expect(result).toHaveProperty('code', 'LIMIT_EXCEEDED')
+  assert.ok(result instanceof Error)
+  assert.deepStrictEqual(result['code'], 'LIMIT_EXCEEDED')
 })
 
 if (suite.provider !== 'cloudinary')
@@ -307,11 +307,11 @@ if (suite.provider !== 'cloudinary')
 
     assert.ok(!(entry instanceof Error))
 
-    expect(entry.attributes.origin).toBe(origin)
+    assert.strictEqual(entry.attributes.origin, origin)
   })
 
 it('should expose path', () => {
   const path = storage.path()
 
-  expect(typeof path === 'string' || path === null)
+  assert.ok(typeof path === 'string' || path === null)
 })

package/source/Storage.ts

@@ -1,11 +1,11 @@
 import { basename, dirname, join } from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { console, type SpanOptions } from 'openspan'
-import { Scanner } from './Scanner'
+import { Scanner } from './Scanner.js'
 import type { Readable } from 'node:stream'
-import type { Attributes, Entry, Stream } from './Entry'
-import type { ScanOptions } from './Scanner'
-import type { Provider } from './Provider'
+import type { Attributes, Entry, Stream } from './Entry.js'
+import type { ScanOptions } from './Scanner.js'
+import type { Provider } from './Provider.js'
 
 export class Storage<T extends Provider = Provider> {
   private readonly provider: T

package/source/deployment.ts

@@ -1,7 +1,7 @@
 import * as assert from 'node:assert'
-import { providers } from './providers'
-import { validateAnnotation } from './Annotation'
-import type { Annotation } from './Annotation'
+import { providers } from './providers/index.js'
+import { validateAnnotation } from './Annotation.js'
+import type { Annotation } from './Annotation.js'
 import type { Dependency, Variable, Mounts } from '@toa.io/operations'
 import type { context } from '@toa.io/norm'
 

package/source/index.ts

@@ -1,7 +1,7 @@
-export { Factory } from './Factory'
-export { deployment } from './deployment'
-export { manifest } from './manifest'
+export { Factory } from './Factory.js'
+export { deployment } from './deployment.js'
+export { manifest } from './manifest.js'
 
-export type { Entry, Stream } from './Entry'
-export type { Storage } from './Storage'
-export type * from './providers'
+export type { Entry, Stream } from './Entry.js'
+export type { Storage } from './Storage.js'
+export type * from './providers/index.js'

package/source/providers/Cloudinary.ts

@@ -2,11 +2,11 @@ import { basename, dirname, join } from 'node:path'
 import { Readable } from 'node:stream'
 import { v2 as cloudinary } from 'cloudinary'
 import { console } from 'openspan'
-import { Provider } from '../Provider'
-import { ERR_NOT_FOUND } from '../errors'
+import { Provider } from '../Provider.js'
+import { ERR_NOT_FOUND } from '../errors.js'
 import type { Maybe } from '@toa.io/types'
-import type { Metadata, Stream } from '../Entry'
-import type { Secret, Secrets } from '../Secrets'
+import type { Metadata, Stream } from '../Entry.js'
+import type { Secret, Secrets } from '../Secrets.js'
 import type { ReadableStream } from 'node:stream/web'
 import type {
   ConfigOptions,

package/source/providers/Declaration.ts

@@ -1,8 +1,8 @@
-import type { S3Options } from './S3'
-import type { SpacesOptions } from './Spaces'
-import type { CloudinaryOptions } from './Cloudinary'
-import type { FileSystemOptions } from './FileSystem'
-import type { TemporaryOptions } from './Temporary'
+import type { S3Options } from './S3.js'
+import type { SpacesOptions } from './Spaces.js'
+import type { CloudinaryOptions } from './Cloudinary.js'
+import type { FileSystemOptions } from './FileSystem.js'
+import type { TemporaryOptions } from './Temporary.js'
 
 export type Declaration =
   ({ provider: 's3' } & S3Options)

package/source/providers/FileSystem.ts

@@ -1,11 +1,11 @@
 import fs from 'node:fs/promises'
 import { createReadStream } from 'node:fs'
 import { dirname, join } from 'node:path'
-import { Provider } from '../Provider'
-import { ERR_NOT_FOUND } from '../errors'
+import { Provider } from '../Provider.js'
+import { ERR_NOT_FOUND } from '../errors.js'
 import type { Readable } from 'node:stream'
 import type { Maybe } from '@toa.io/types'
-import type { Metadata, Stream } from '../Entry'
+import type { Metadata, Stream } from '../Entry.js'
 
 export interface FileSystemOptions {
   path: string

package/source/providers/S3.ts

@@ -5,12 +5,12 @@ import assert from 'node:assert'
 import { Upload } from '@aws-sdk/lib-storage'
 import * as s3 from '@aws-sdk/client-s3'
 import { console } from 'openspan'
-import { Provider } from '../Provider'
-import { ERR_NOT_FOUND } from '../errors'
+import { Provider } from '../Provider.js'
+import { ERR_NOT_FOUND } from '../errors.js'
 import type { ReadableStream } from 'node:stream/web'
 import type { Maybe } from '@toa.io/types'
-import type { Metadata, Stream } from '../Entry'
-import type { Secret, Secrets } from '../Secrets'
+import type { Metadata, Stream } from '../Entry.js'
+import type { Secret, Secrets } from '../Secrets.js'
 
 export interface S3Options {
   bucket: string

package/source/providers/Spaces.ts

@@ -1,5 +1,5 @@
-import { S3 } from './S3'
-import type { Secret, Secrets } from '../Secrets'
+import { S3 } from './S3.js'
+import type { Secret, Secrets } from '../Secrets.js'
 
 export interface SpacesOptions {
   space: string

package/source/providers/Temporary.ts

@@ -1,6 +1,6 @@
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { FileSystem } from './FileSystem'
+import { FileSystem } from './FileSystem.js'
 
 export interface TemporaryOptions {
   directory: string

package/source/providers/Test.ts

@@ -1,5 +1,5 @@
-import { Temporary, type TemporaryOptions } from './Temporary'
-import type { Secret } from '../Secrets'
+import { Temporary, type TemporaryOptions } from './Temporary.js'
+import type { Secret } from '../Secrets.js'
 
 export class Test extends Temporary {
   public static override readonly SECRETS: readonly Secret[] = [