@owlmeans/storage-common 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,599 @@
+# @owlmeans/storage-common
+
+Common storage interfaces and utilities for OwlMeans file storage systems. This package provides shared types, validation schemas, and error handling for object storage solutions including S3-compatible storage, image storage, and file management systems.
+
+## Overview
+
+The `@owlmeans/storage-common` package serves as the foundation for OwlMeans storage implementations. It provides:
+
+- **File Storage Interfaces**: Common types for stored files and file metadata
+- **Validation Schemas**: AJV schemas for file validation and integrity
+- **Status Management**: File status tracking and lifecycle management
+- **Format Support**: Multiple file formats and encoding support
+- **Scope-Based Access**: Authorization scopes for file access control
+- **Error Types**: Specialized error types for storage operations
+- **Instance Management**: Multiple file instances and versions support
+
+This package is part of the OwlMeans storage ecosystem:
+- **@owlmeans/storage-common**: Common storage interfaces *(this package)*
+- **@owlmeans/storage-resource**: Storage resource implementations
+- **@owlmeans/static-resource**: Static resource management
+- **@owlmeans/image-resource**: Image-specific storage features
+
+## Installation
+
+```bash
+npm install @owlmeans/storage-common ajv
+```
+
+## Core Concepts
+
+### Stored Files
+Files are represented with metadata, multiple instances (different sizes/formats), and access control through scopes.
+
+### File Instances
+Each file can have multiple instances representing different versions, sizes, or formats of the same file.
+
+### Scope-Based Access
+Files use scope-based authorization to control who can access, modify, or delete files.
+
+### Status Tracking
+Files have status indicators to track their lifecycle from upload to processing to availability.
+
+## API Reference
+
+### Core Types
+
+#### `StoredFileMeta`
+
+Metadata interface for stored files with authorization and identification.
+
+```typescript
+interface StoredFileMeta {
+  entityId?: string           // Associated entity identifier
+  sourceName?: string         // Original filename from upload
+  name?: string              // Display name for the file
+  title?: string             // Human-readable title
+  scopes: string[]           // Authorization scopes
+  mimeType: string           // MIME type of the file
+  alias: string              // Unique file identifier
+  status: StoredFileStatus   // Current file status
+}
+```
+
+#### `StoredFileInstance`
+
+Represents a specific instance of a stored file.
+
+```typescript
+interface StoredFileInstance {
+  size: number               // File size in bytes
+  alias: string              // Instance identifier
+  url: string                // Access URL for this instance
+}
+```
+
+#### `StoredFilePayload`
+
+Extended instance with actual file data for upload/download operations.
+
+```typescript
+interface StoredFilePayload extends StoredFileInstance {
+  format?: StoredFileFormat  // File format information
+  bytes?: Uint8Array         // Raw file bytes
+  base64?: string           // Base64 encoded file data
+}
+```
+
+#### `StoredFile`
+
+Complete file representation with metadata and all instances.
+
+```typescript
+interface StoredFile extends StoredFileMeta {
+  instances: { [key: string]: StoredFileInstance }
+}
+```
+
+#### `StoredFileWithData`
+
+File representation including actual file data for each instance.
+
+```typescript
+interface StoredFileWithData extends StoredFileMeta {
+  format?: StoredFileFormat
+  instances: { [key: string]: StoredFilePayload }
+}
+```
+
+### Enums and Constants
+
+#### `StoredFileStatus`
+
+Enumeration of possible file statuses.
+
+```typescript
+enum StoredFileStatus {
+  Uploaded = 'uploaded',      // File has been uploaded
+  Processing = 'processing',  // File is being processed
+  Available = 'available',    // File is available for use
+  Error = 'error',           // File processing failed
+  Deleted = 'deleted'        // File has been deleted
+}
+```
+
+#### `StoredFileFormat`
+
+Enumeration of supported file formats.
+
+```typescript
+enum StoredFileFormat {
+  Original = 'original',      // Original uploaded format
+  Thumbnail = 'thumbnail',    // Thumbnail version
+  Compressed = 'compressed',  // Compressed version
+  Optimized = 'optimized'     // Optimized version
+}
+```
+
+### Validation Schemas
+
+The package provides AJV schemas for runtime validation:
+
+#### `StoredFileMetaSchema`
+
+Validates stored file metadata.
+
+```typescript
+const StoredFileMetaSchema: JSONSchemaType<StoredFileMeta>
+```
+
+#### `StoredFileInstanceSchema`
+
+Validates file instance data.
+
+```typescript
+const StoredFileInstanceSchema: JSONSchemaType<StoredFileInstance>
+```
+
+#### `StoredFilePayloadSchema`
+
+Validates file payload including data.
+
+```typescript
+const StoredFilePayloadSchema: JSONSchemaType<StoredFilePayload>
+```
+
+### Error Types
+
+The package defines storage-specific error types for comprehensive error handling.
+
+```typescript
+import { StorageError } from '@owlmeans/storage-common'
+
+// Storage operation errors
+class StorageError extends OwlMeansError {
+  // Storage-specific error handling
+}
+```
+
+## Usage Examples
+
+### Basic File Metadata Management
+
+```typescript
+import { 
+  StoredFileMeta, 
+  StoredFileStatus, 
+  StoredFileMetaSchema 
+} from '@owlmeans/storage-common'
+import Ajv from 'ajv'
+
+const ajv = new Ajv()
+const validateMeta = ajv.compile(StoredFileMetaSchema)
+
+// Create file metadata
+const fileMeta: StoredFileMeta = {
+  entityId: 'user-123',
+  sourceName: 'document.pdf',
+  name: 'Important Document',
+  title: 'Project Requirements Document',
+  scopes: ['read:documents', 'entity:user-123'],
+  mimeType: 'application/pdf',
+  alias: 'doc-abc123',
+  status: StoredFileStatus.Uploaded
+}
+
+// Validate metadata
+if (validateMeta(fileMeta)) {
+  console.log('File metadata is valid')
+} else {
+  console.error('Validation errors:', validateMeta.errors)
+}
+```
+
+### File Instance Management
+
+```typescript
+import { 
+  StoredFile, 
+  StoredFileInstance, 
+  StoredFileFormat 
+} from '@owlmeans/storage-common'
+
+// Create file with multiple instances
+const fileWithInstances: StoredFile = {
+  // ... metadata
+  entityId: 'user-123',
+  sourceName: 'photo.jpg',
+  name: 'Profile Photo',
+  scopes: ['read:photos', 'entity:user-123'],
+  mimeType: 'image/jpeg',
+  alias: 'photo-xyz789',
+  status: StoredFileStatus.Available,
+  
+  instances: {
+    original: {
+      size: 2048000,
+      alias: 'photo-xyz789-original',
+      url: 'https://storage.example.com/photos/original/photo-xyz789.jpg'
+    },
+    thumbnail: {
+      size: 51200,
+      alias: 'photo-xyz789-thumb',
+      url: 'https://storage.example.com/photos/thumbnails/photo-xyz789.jpg'
+    },
+    compressed: {
+      size: 512000,
+      alias: 'photo-xyz789-compressed',
+      url: 'https://storage.example.com/photos/compressed/photo-xyz789.jpg'
+    }
+  }
+}
+
+// Access different file instances
+const originalUrl = fileWithInstances.instances.original.url
+const thumbnailUrl = fileWithInstances.instances.thumbnail.url
+```
+
+### File Upload with Payload
+
+```typescript
+import { 
+  StoredFileWithData, 
+  StoredFilePayload, 
+  StoredFileFormat 
+} from '@owlmeans/storage-common'
+
+// File upload with data
+const uploadFile = async (fileData: Uint8Array, metadata: StoredFileMeta): Promise<StoredFileWithData> => {
+  const fileWithData: StoredFileWithData = {
+    ...metadata,
+    format: StoredFileFormat.Original,
+    instances: {
+      original: {
+        size: fileData.length,
+        alias: `${metadata.alias}-original`,
+        url: '', // Will be set after upload
+        format: StoredFileFormat.Original,
+        bytes: fileData
+      }
+    }
+  }
+  
+  return fileWithData
+}
+
+// Usage
+const fileBytes = new Uint8Array([/* file data */])
+const metadata: StoredFileMeta = {
+  sourceName: 'upload.png',
+  name: 'User Upload',
+  scopes: ['read:uploads'],
+  mimeType: 'image/png',
+  alias: 'upload-123',
+  status: StoredFileStatus.Uploaded
+}
+
+const uploadedFile = await uploadFile(fileBytes, metadata)
+```
+
+### Base64 File Handling
+
+```typescript
+import { StoredFilePayload, StoredFileFormat } from '@owlmeans/storage-common'
+
+// Convert base64 to file payload
+const base64ToPayload = (base64Data: string, alias: string): StoredFilePayload => {
+  // Decode base64 to calculate size
+  const bytes = Uint8Array.from(atob(base64Data), c => c.charCodeAt(0))
+  
+  return {
+    size: bytes.length,
+    alias,
+    url: '', // Will be set after storage
+    format: StoredFileFormat.Original,
+    base64: base64Data,
+    bytes
+  }
+}
+
+// Convert file payload to base64
+const payloadToBase64 = (payload: StoredFilePayload): string => {
+  if (payload.base64) {
+    return payload.base64
+  }
+  
+  if (payload.bytes) {
+    return btoa(String.fromCharCode(...payload.bytes))
+  }
+  
+  throw new Error('No data available for base64 conversion')
+}
+```
+
+### Scope-Based Authorization
+
+```typescript
+import { StoredFileMeta } from '@owlmeans/storage-common'
+
+class FileAuthorizationManager {
+  canAccess(file: StoredFileMeta, userScopes: string[]): boolean {
+    return file.scopes.some(scope => userScopes.includes(scope))
+  }
+  
+  canModify(file: StoredFileMeta, userScopes: string[], entityId?: string): boolean {
+    // Check if user has modify access
+    const hasModifyScope = userScopes.some(scope => 
+      scope.startsWith('write:') || scope.startsWith('modify:')
+    )
+    
+    // Check entity-specific access
+    const hasEntityAccess = entityId && file.entityId === entityId &&
+      userScopes.includes(`entity:${entityId}`)
+    
+    return hasModifyScope && (hasEntityAccess || !file.entityId)
+  }
+  
+  filterAccessibleFiles(files: StoredFileMeta[], userScopes: string[]): StoredFileMeta[] {
+    return files.filter(file => this.canAccess(file, userScopes))
+  }
+}
+
+// Usage
+const authManager = new FileAuthorizationManager()
+const userScopes = ['read:documents', 'entity:user-123']
+
+const canRead = authManager.canAccess(fileMeta, userScopes)
+const canWrite = authManager.canModify(fileMeta, ['write:documents', 'entity:user-123'], 'user-123')
+```
+
+### File Status Management
+
+```typescript
+import { StoredFile, StoredFileStatus } from '@owlmeans/storage-common'
+
+class FileStatusManager {
+  updateStatus(file: StoredFile, newStatus: StoredFileStatus): StoredFile {
+    return {
+      ...file,
+      status: newStatus
+    }
+  }
+  
+  isAvailable(file: StoredFile): boolean {
+    return file.status === StoredFileStatus.Available
+  }
+  
+  isProcessing(file: StoredFile): boolean {
+    return file.status === StoredFileStatus.Processing
+  }
+  
+  hasError(file: StoredFile): boolean {
+    return file.status === StoredFileStatus.Error
+  }
+  
+  getProcessingFiles(files: StoredFile[]): StoredFile[] {
+    return files.filter(file => this.isProcessing(file))
+  }
+  
+  getAvailableFiles(files: StoredFile[]): StoredFile[] {
+    return files.filter(file => this.isAvailable(file))
+  }
+}
+
+// Usage
+const statusManager = new FileStatusManager()
+
+// Update file status after processing
+const processedFile = statusManager.updateStatus(file, StoredFileStatus.Available)
+
+// Check file availability
+if (statusManager.isAvailable(file)) {
+  console.log('File is ready for use')
+}
+```
+
+### File Format Management
+
+```typescript
+import { 
+  StoredFileWithData, 
+  StoredFileFormat, 
+  StoredFilePayload 
+} from '@owlmeans/storage-common'
+
+class FileFormatManager {
+  addInstance(
+    file: StoredFileWithData, 
+    format: StoredFileFormat, 
+    payload: StoredFilePayload
+  ): StoredFileWithData {
+    return {
+      ...file,
+      instances: {
+        ...file.instances,
+        [format]: {
+          ...payload,
+          format
+        }
+      }
+    }
+  }
+  
+  getInstanceByFormat(file: StoredFileWithData, format: StoredFileFormat): StoredFilePayload | null {
+    return file.instances[format] || null
+  }
+  
+  hasFormat(file: StoredFileWithData, format: StoredFileFormat): boolean {
+    return format in file.instances
+  }
+  
+  getAvailableFormats(file: StoredFileWithData): StoredFileFormat[] {
+    return Object.keys(file.instances)
+      .filter(key => file.instances[key].format)
+      .map(key => file.instances[key].format!)
+  }
+}
+
+// Usage
+const formatManager = new FileFormatManager()
+
+// Add thumbnail instance
+const thumbnailPayload: StoredFilePayload = {
+  size: 10240,
+  alias: 'file-thumb',
+  url: 'https://storage.example.com/thumbnails/file-thumb.jpg',
+  format: StoredFileFormat.Thumbnail,
+  bytes: thumbnailBytes
+}
+
+const fileWithThumbnail = formatManager.addInstance(
+  originalFile, 
+  StoredFileFormat.Thumbnail, 
+  thumbnailPayload
+)
+
+// Get specific format
+const thumbnail = formatManager.getInstanceByFormat(fileWithThumbnail, StoredFileFormat.Thumbnail)
+```
+
+### Validation and Error Handling
+
+```typescript
+import { 
+  StoredFileMetaSchema, 
+  StoredFileInstanceSchema,
+  StorageError 
+} from '@owlmeans/storage-common'
+import Ajv from 'ajv'
+
+const ajv = new Ajv()
+const validateMeta = ajv.compile(StoredFileMetaSchema)
+const validateInstance = ajv.compile(StoredFileInstanceSchema)
+
+class FileValidator {
+  validateMetadata(meta: unknown): StoredFileMeta {
+    if (!validateMeta(meta)) {
+      throw new StorageError('Invalid file metadata', {
+        code: 'VALIDATION_ERROR',
+        details: validateMeta.errors
+      })
+    }
+    return meta as StoredFileMeta
+  }
+  
+  validateInstance(instance: unknown): StoredFileInstance {
+    if (!validateInstance(instance)) {
+      throw new StorageError('Invalid file instance', {
+        code: 'VALIDATION_ERROR', 
+        details: validateInstance.errors
+      })
+    }
+    return instance as StoredFileInstance
+  }
+  
+  validateFile(file: unknown): StoredFile {
+    const meta = this.validateMetadata(file)
+    
+    if (typeof file === 'object' && file !== null && 'instances' in file) {
+      const instances = (file as any).instances
+      
+      if (typeof instances !== 'object') {
+        throw new StorageError('Invalid instances object')
+      }
+      
+      // Validate each instance
+      Object.values(instances).forEach(instance => {
+        this.validateInstance(instance)
+      })
+      
+      return file as StoredFile
+    }
+    
+    throw new StorageError('Invalid file structure')
+  }
+}
+
+// Usage
+const validator = new FileValidator()
+
+try {
+  const validFile = validator.validateFile(untrustedFileData)
+  console.log('File validation passed')
+} catch (error) {
+  if (error instanceof StorageError) {
+    console.error('Storage validation error:', error.message)
+    console.error('Details:', error.details)
+  }
+}
+```
+
+## Integration with Other Packages
+
+### Authentication Integration
+```typescript
+import { ScopeValueSchema } from '@owlmeans/auth'
+import { StoredFileMeta } from '@owlmeans/storage-common'
+
+// File scopes use authentication scope validation
+```
+
+### Error System Integration
+```typescript
+import { OwlMeansError } from '@owlmeans/error'
+import { StorageError } from '@owlmeans/storage-common'
+
+// Storage errors extend the OwlMeans error system
+```
+
+### Resource Integration
+```typescript
+import { StoredFile } from '@owlmeans/storage-common'
+import { Resource } from '@owlmeans/resource'
+
+// Storage resources can use these types for consistent file management
+```
+
+## Best Practices
+
+1. **Scope Management**: Use specific scopes for fine-grained access control
+2. **Status Tracking**: Always update file status during processing
+3. **Instance Management**: Use appropriate instances for different use cases
+4. **Validation**: Always validate file data using provided schemas
+5. **Error Handling**: Use storage-specific error types for better debugging
+6. **Format Support**: Provide multiple formats for better user experience
+7. **Security**: Validate all file metadata and content before storage
+
+## Dependencies
+
+This package depends on:
+- `@owlmeans/auth` - Authentication and authorization utilities
+- `@owlmeans/error` - Error handling system
+- `ajv` - JSON Schema validation (peer dependency)
+
+## Related Packages
+
+- [`@owlmeans/storage-resource`](../storage-resource) - Storage resource implementations
+- [`@owlmeans/static-resource`](../static-resource) - Static resource management
+- [`@owlmeans/image-resource`](../image-resource) - Image-specific storage
+- [`@owlmeans/auth`](../auth) - Authentication and authorization

package/build/consts.d.ts

@@ -0,0 +1,12 @@
+export declare enum StoredFileStatus {
+    Uploaded = "uploaded",
+    ProcessingReady = "processing-ready",
+    Processed = "processed",
+    Cached = "cached",
+    Unknown = "unknown"
+}
+export declare enum StoredFileFormat {
+    Bytes = "bytes",
+    Base64 = "base64"
+}
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,oBAAY,gBAAgB;IAC1B,QAAQ,aAAa;IACrB,eAAe,qBAAqB;IACpC,SAAS,cAAc;IACvB,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AAED,oBAAY,gBAAgB;IAC1B,KAAK,UAAU;IACf,MAAM,WAAW;CAClB"}

package/build/consts.js

@@ -0,0 +1,14 @@
+export var StoredFileStatus;
+(function (StoredFileStatus) {
+    StoredFileStatus["Uploaded"] = "uploaded";
+    StoredFileStatus["ProcessingReady"] = "processing-ready";
+    StoredFileStatus["Processed"] = "processed";
+    StoredFileStatus["Cached"] = "cached";
+    StoredFileStatus["Unknown"] = "unknown";
+})(StoredFileStatus || (StoredFileStatus = {}));
+export var StoredFileFormat;
+(function (StoredFileFormat) {
+    StoredFileFormat["Bytes"] = "bytes";
+    StoredFileFormat["Base64"] = "base64";
+})(StoredFileFormat || (StoredFileFormat = {}));
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,gBAMX;AAND,WAAY,gBAAgB;IAC1B,yCAAqB,CAAA;IACrB,wDAAoC,CAAA;IACpC,2CAAuB,CAAA;IACvB,qCAAiB,CAAA;IACjB,uCAAmB,CAAA;AACrB,CAAC,EANW,gBAAgB,KAAhB,gBAAgB,QAM3B;AAED,MAAM,CAAN,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,mCAAe,CAAA;IACf,qCAAiB,CAAA;AACnB,CAAC,EAHW,gBAAgB,KAAhB,gBAAgB,QAG3B"}

package/build/errors.d.ts

@@ -0,0 +1,26 @@
+import { ResilientError } from '@owlmeans/error';
+export declare class StoredFileError extends ResilientError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class OrphanFileError extends StoredFileError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class FilePropertyError extends StoredFileError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class FileStreamError extends FilePropertyError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class StorageApiError extends StoredFileError {
+    static typeName: string;
+    constructor(message?: string);
+}
+export declare class FileTypeError extends StoredFileError {
+    static typeName: string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/build/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,qBAAa,eAAgB,SAAQ,cAAc;IACjD,OAAuB,QAAQ,EAAE,MAAM,CAAoB;gBAE/C,OAAO,GAAE,MAAgB;CAGtC;AAED,qBAAa,eAAgB,SAAQ,eAAe;IAClD,OAAuB,QAAQ,EAAE,MAAM,CAAsC;gBAEjE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,iBAAkB,SAAQ,eAAe;IACpD,OAAuB,QAAQ,EAAE,MAAM,CAAwC;gBAEnE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,eAAgB,SAAQ,iBAAiB;IACpD,OAAuB,QAAQ,EAAE,MAAM,CAA0C;gBAErE,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,eAAgB,SAAQ,eAAe;IAClD,OAAuB,QAAQ,EAAE,MAAM,CAAmC;gBAE9D,OAAO,GAAE,MAAgB;CAItC;AAED,qBAAa,aAAc,SAAQ,eAAe;IAChD,OAAuB,QAAQ,EAAE,MAAM,CAAoC;gBAE/D,OAAO,GAAE,MAAgB;CAItC"}

package/build/errors.js

@@ -0,0 +1,49 @@
+import { ResilientError } from '@owlmeans/error';
+export class StoredFileError extends ResilientError {
+    static typeName = 'StoredFileError';
+    constructor(message = 'error') {
+        super(StoredFileError.typeName, `stored-file:${message}`);
+    }
+}
+export class OrphanFileError extends StoredFileError {
+    static typeName = `${StoredFileError.typeName}Orphan`;
+    constructor(message = 'error') {
+        super(`orphan:${message}`);
+        this.type = OrphanFileError.typeName;
+    }
+}
+export class FilePropertyError extends StoredFileError {
+    static typeName = `${StoredFileError.typeName}Property`;
+    constructor(message = 'error') {
+        super(`property:${message}`);
+        this.type = FilePropertyError.typeName;
+    }
+}
+export class FileStreamError extends FilePropertyError {
+    static typeName = `${StoredFileError.typeName}FileStream`;
+    constructor(message = 'error') {
+        super(`creation:${message}`);
+        this.type = FileStreamError.typeName;
+    }
+}
+export class StorageApiError extends StoredFileError {
+    static typeName = `${StoredFileError.typeName}Api`;
+    constructor(message = 'error') {
+        super(`api:${message}`);
+        this.type = StorageApiError.typeName;
+    }
+}
+export class FileTypeError extends StoredFileError {
+    static typeName = `${StoredFileError.typeName}Type`;
+    constructor(message = 'error') {
+        super(`type:${message}`);
+        this.type = FileTypeError.typeName;
+    }
+}
+ResilientError.registerErrorClass(StoredFileError);
+ResilientError.registerErrorClass(OrphanFileError);
+ResilientError.registerErrorClass(FilePropertyError);
+ResilientError.registerErrorClass(FileStreamError);
+ResilientError.registerErrorClass(StorageApiError);
+ResilientError.registerErrorClass(FileTypeError);
+//# sourceMappingURL=errors.js.map

package/build/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,MAAM,OAAO,eAAgB,SAAQ,cAAc;IAC1C,MAAM,CAAU,QAAQ,GAAW,iBAAiB,CAAA;IAE3D,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,eAAe,OAAO,EAAE,CAAC,CAAA;IAC3D,CAAC;;AAGH,MAAM,OAAO,eAAgB,SAAQ,eAAe;IAC3C,MAAM,CAAU,QAAQ,GAAW,GAAG,eAAe,CAAC,QAAQ,QAAQ,CAAA;IAE7E,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,UAAU,OAAO,EAAE,CAAC,CAAA;QAC1B,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAA;IACtC,CAAC;;AAGH,MAAM,OAAO,iBAAkB,SAAQ,eAAe;IAC7C,MAAM,CAAU,QAAQ,GAAW,GAAG,eAAe,CAAC,QAAQ,UAAU,CAAA;IAE/E,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,YAAY,OAAO,EAAE,CAAC,CAAA;QAC5B,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC,QAAQ,CAAA;IACxC,CAAC;;AAGH,MAAM,OAAO,eAAgB,SAAQ,iBAAiB;IAC7C,MAAM,CAAU,QAAQ,GAAW,GAAG,eAAe,CAAC,QAAQ,YAAY,CAAA;IAEjF,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,YAAY,OAAO,EAAE,CAAC,CAAA;QAC5B,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAA;IACtC,CAAC;;AAGH,MAAM,OAAO,eAAgB,SAAQ,eAAe;IAC3C,MAAM,CAAU,QAAQ,GAAW,GAAG,eAAe,CAAC,QAAQ,KAAK,CAAA;IAE1E,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,OAAO,OAAO,EAAE,CAAC,CAAA;QACvB,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAA;IACtC,CAAC;;AAGH,MAAM,OAAO,aAAc,SAAQ,eAAe;IACzC,MAAM,CAAU,QAAQ,GAAW,GAAG,eAAe,CAAC,QAAQ,MAAM,CAAA;IAE3E,YAAY,UAAkB,OAAO;QACnC,KAAK,CAAC,QAAQ,OAAO,EAAE,CAAC,CAAA;QACxB,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC,QAAQ,CAAA;IACpC,CAAC;;AAGH,cAAc,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAA;AAClD,cAAc,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAA;AAClD,cAAc,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAA;AACpD,cAAc,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAA;AAClD,cAAc,CAAC,kBAAkB,CAAC,eAAe,CAAC,CAAA;AAClD,cAAc,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAA"}

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './types.js';
+export * from './consts.js';
+export * from './model.js';
+export * from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,mBAAmB,YAAY,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -0,0 +1,4 @@
+export * from './consts.js';
+export * from './model.js';
+export * from './errors.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}

package/build/model.d.ts

@@ -0,0 +1,8 @@
+import type { JSONSchemaType } from 'ajv';
+import type { StoredFileInstance, StoredFileMeta } from './types.js';
+export declare const StoredFileMetaSchema: JSONSchemaType<StoredFileMeta>;
+export declare const StoredFileInstanceSchema: JSONSchemaType<StoredFileInstance>;
+export declare const StoredFilePayloadSchema: JSONSchemaType<StoredFileInstance>;
+export declare const StoredFileSchema: JSONSchemaType<StoredFileMeta>;
+export declare const StoredFileWithDataSchema: JSONSchemaType<StoredFileMeta>;
+//# sourceMappingURL=model.d.ts.map

package/build/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,KAAK,CAAA;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAIpE,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,cAAc,CAc/D,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,kBAAkB,CASvE,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAAC,kBAAkB,CAUhC,CAAA;AAEvC,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,cAAc,CAQzB,CAAA;AAEnC,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,cAAc,CASjC,CAAA"}

package/build/model.js

@@ -0,0 +1,58 @@
+import { StoredFileFormat, StoredFileStatus } from './consts.js';
+import { EntityValueSchema, IdValueSchema, ScopeValueSchema } from '@owlmeans/auth';
+export const StoredFileMetaSchema = {
+    type: 'object',
+    properties: {
+        entityId: { ...EntityValueSchema, nullable: true },
+        sourceName: { type: 'string', minLength: 1, maxLength: 255, nullable: true },
+        name: { type: 'string', minLength: 1, maxLength: 128, nullable: true },
+        title: { type: 'string', minLength: 1, maxLength: 255, nullable: true },
+        scopes: { type: 'array', items: { ...ScopeValueSchema } },
+        mimeType: { type: 'string', minLength: 1, maxLength: 32 },
+        alias: { ...IdValueSchema },
+        status: { type: 'string', enum: Object.values(StoredFileStatus) }
+    },
+    required: ['scopes', 'mimeType', 'alias', 'status'],
+    additionalProperties: false,
+};
+export const StoredFileInstanceSchema = {
+    type: 'object',
+    properties: {
+        size: { type: 'number', default: 0 },
+        alias: { ...IdValueSchema },
+        url: { type: 'string', format: 'uri' }
+    },
+    required: ['size', 'alias', 'url'],
+    additionalProperties: false,
+};
+export const StoredFilePayloadSchema = {
+    type: 'object',
+    properties: {
+        ...StoredFileInstanceSchema.properties,
+        format: { type: 'string', enum: Object.values(StoredFileFormat), nullable: true },
+        bytes: { type: 'array', items: { type: 'uint8' }, nullable: true },
+        base64: { type: 'string', format: 'byte', nullable: true },
+    },
+    required: [...StoredFileInstanceSchema.required],
+    additionalProperties: false,
+};
+export const StoredFileSchema = {
+    type: 'object',
+    properties: {
+        ...StoredFileMetaSchema.properties,
+        instances: { type: 'object', additionalProperties: { ...StoredFileInstanceSchema } },
+    },
+    required: [...StoredFileMetaSchema.required, 'instances'],
+    additionalProperties: false,
+};
+export const StoredFileWithDataSchema = {
+    type: 'object',
+    properties: {
+        ...StoredFileMetaSchema.properties,
+        format: { type: 'string', enum: Object.values(StoredFileFormat), nullable: true },
+        instances: { type: 'object', additionalProperties: { ...StoredFilePayloadSchema } },
+    },
+    required: [...StoredFileMetaSchema.required, 'instances'],
+    additionalProperties: false,
+};
+//# sourceMappingURL=model.js.map

package/build/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"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"}

package/build/types.d.ts

@@ -0,0 +1,33 @@
+import type { StoredFileFormat, StoredFileStatus } from './consts.js';
+export interface StoredFileMeta {
+    entityId?: string;
+    sourceName?: string;
+    name?: string;
+    title?: string;
+    scopes: string[];
+    mimeType: string;
+    alias: string;
+    status: StoredFileStatus;
+}
+export interface StoredFileInstance {
+    size: number;
+    alias: string;
+    url: string;
+}
+export interface StoredFilePayload extends StoredFileInstance {
+    format?: StoredFileFormat;
+    bytes?: Uint8Array;
+    base64?: string;
+}
+export interface StoredFile extends StoredFileMeta {
+    instances: {
+        [key: string]: StoredFileInstance;
+    };
+}
+export interface StoredFileWithData extends StoredFileMeta {
+    format?: StoredFileFormat;
+    instances: {
+        [key: string]: StoredFilePayload;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAErE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,gBAAgB,CAAA;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;IAC3D,MAAM,CAAC,EAAE,gBAAgB,CAAA;IACzB,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,UAAW,SAAQ,cAAc;IAChD,SAAS,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAA;KAAE,CAAA;CACjD;AAED,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD,MAAM,CAAC,EAAE,gBAAgB,CAAA;IACzB,SAAS,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAA;KAAE,CAAA;CAChD"}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@owlmeans/storage-common",
+  "type": "module",
+  "version": "0.1.0",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "sleep 387 && nodemon -e ts,tsx,json --watch src --exec \"tsc -p ./tsconfig.json\"",
+    "watch": "tsc -b -w --preserveWatchOutput --pretty"
+  },
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "require": "./build/index.js",
+      "default": "./build/index.js",
+      "module": "./build/index.js",
+      "types": "./build/index.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "ajv": "*"
+  },
+  "dependencies": {
+    "@owlmeans/auth": "^0.1.0",
+    "@owlmeans/error": "^0.1.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.7",
+    "typescript": "^5.6.3"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/consts.ts

@@ -0,0 +1,12 @@
+export enum StoredFileStatus {
+  Uploaded = 'uploaded',
+  ProcessingReady = 'processing-ready',
+  Processed = 'processed',
+  Cached = 'cached',
+  Unknown = 'unknown'
+}
+
+export enum StoredFileFormat {
+  Bytes = 'bytes',
+  Base64 = 'base64'
+}

package/src/errors.ts

@@ -0,0 +1,61 @@
+import { ResilientError } from '@owlmeans/error'
+
+export class StoredFileError extends ResilientError {
+  public static override typeName: string = 'StoredFileError'
+
+  constructor(message: string = 'error') {
+    super(StoredFileError.typeName, `stored-file:${message}`)
+  }
+}
+
+export class OrphanFileError extends StoredFileError {
+  public static override typeName: string = `${StoredFileError.typeName}Orphan`
+
+  constructor(message: string = 'error') {
+    super(`orphan:${message}`)
+    this.type = OrphanFileError.typeName
+  }
+}
+
+export class FilePropertyError extends StoredFileError {
+  public static override typeName: string = `${StoredFileError.typeName}Property`
+
+  constructor(message: string = 'error') {
+    super(`property:${message}`)
+    this.type = FilePropertyError.typeName
+  }
+}
+
+export class FileStreamError extends FilePropertyError {
+  public static override typeName: string = `${StoredFileError.typeName}FileStream`
+
+  constructor(message: string = 'error') {
+    super(`creation:${message}`)
+    this.type = FileStreamError.typeName
+  }
+}
+
+export class StorageApiError extends StoredFileError {
+  public static override typeName: string = `${StoredFileError.typeName}Api`
+
+  constructor(message: string = 'error') {
+    super(`api:${message}`)
+    this.type = StorageApiError.typeName
+  }
+}
+
+export class FileTypeError extends StoredFileError {
+  public static override typeName: string = `${StoredFileError.typeName}Type`
+
+  constructor(message: string = 'error') {
+    super(`type:${message}`)
+    this.type = FileTypeError.typeName
+  }
+}
+
+ResilientError.registerErrorClass(StoredFileError)
+ResilientError.registerErrorClass(OrphanFileError)
+ResilientError.registerErrorClass(FilePropertyError)
+ResilientError.registerErrorClass(FileStreamError)
+ResilientError.registerErrorClass(StorageApiError)
+ResilientError.registerErrorClass(FileTypeError)

package/src/index.ts

@@ -0,0 +1,5 @@
+
+export type * from './types.js'
+export * from './consts.js'
+export * from './model.js'
+export * from './errors.js'

package/src/model.ts

@@ -0,0 +1,64 @@
+import type { JSONSchemaType } from 'ajv'
+import type { StoredFileInstance, StoredFileMeta } from './types.js'
+import { StoredFileFormat, StoredFileStatus } from './consts.js'
+import { EntityValueSchema, IdValueSchema, ScopeValueSchema } from '@owlmeans/auth'
+
+export const StoredFileMetaSchema: JSONSchemaType<StoredFileMeta> = {
+  type: 'object',
+  properties: {
+    entityId: { ...EntityValueSchema, nullable: true },
+    sourceName: { type: 'string', minLength: 1, maxLength: 255, nullable: true },
+    name: { type: 'string', minLength: 1, maxLength: 128, nullable: true },
+    title: { type: 'string', minLength: 1, maxLength: 255, nullable: true },
+    scopes: { type: 'array', items: { ...ScopeValueSchema } },
+    mimeType: { type: 'string', minLength: 1, maxLength: 32 },
+    alias: { ...IdValueSchema },
+    status: { type: 'string', enum: Object.values(StoredFileStatus) }
+  },
+  required: ['scopes', 'mimeType', 'alias', 'status'],
+  additionalProperties: false,
+}
+
+export const StoredFileInstanceSchema: JSONSchemaType<StoredFileInstance> = {
+  type: 'object',
+  properties: {
+    size: { type: 'number', default: 0 },
+    alias: { ...IdValueSchema },
+    url: { type: 'string', format: 'uri' }
+  },
+  required: ['size', 'alias', 'url'],
+  additionalProperties: false,
+}
+
+export const StoredFilePayloadSchema: JSONSchemaType<StoredFileInstance> = {
+  type: 'object',
+  properties: {
+    ...StoredFileInstanceSchema.properties,
+    format: { type: 'string', enum: Object.values(StoredFileFormat), nullable: true },
+    bytes: { type: 'array', items: { type: 'uint8' }, nullable: true },
+    base64: { type: 'string', format: 'byte', nullable: true },
+  },
+  required: [...StoredFileInstanceSchema.required],
+  additionalProperties: false,
+} as JSONSchemaType<StoredFileInstance>
+
+export const StoredFileSchema: JSONSchemaType<StoredFileMeta> = {
+  type: 'object',
+  properties: {
+    ...StoredFileMetaSchema.properties,
+    instances: { type: 'object', additionalProperties: { ...StoredFileInstanceSchema } },
+  },
+  required: [...StoredFileMetaSchema.required, 'instances'],
+  additionalProperties: false,
+} as JSONSchemaType<StoredFileMeta>
+
+export const StoredFileWithDataSchema: JSONSchemaType<StoredFileMeta> = {
+  type: 'object',
+  properties: {
+    ...StoredFileMetaSchema.properties,
+    format: { type: 'string', enum: Object.values(StoredFileFormat), nullable: true },
+    instances: { type: 'object', additionalProperties: { ...StoredFilePayloadSchema } },
+  },
+  required: [...StoredFileMetaSchema.required, 'instances'],
+  additionalProperties: false,
+} as JSONSchemaType<StoredFileMeta>

package/src/types.ts

@@ -0,0 +1,33 @@
+import type { StoredFileFormat, StoredFileStatus } from './consts.js'
+
+export interface StoredFileMeta {
+  entityId?: string
+  sourceName?: string
+  name?: string
+  title?: string
+  scopes: string[]
+  mimeType: string
+  alias: string
+  status: StoredFileStatus
+}
+
+export interface StoredFileInstance {
+  size: number
+  alias: string
+  url: string
+}
+
+export interface StoredFilePayload extends StoredFileInstance {
+  format?: StoredFileFormat
+  bytes?: Uint8Array
+  base64?: string
+}
+
+export interface StoredFile extends StoredFileMeta {
+  instances: { [key: string]: StoredFileInstance }
+}
+
+export interface StoredFileWithData extends StoredFileMeta {
+  format?: StoredFileFormat
+  instances: { [key: string]: StoredFilePayload }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": [
+    "../tsconfig.default.json",
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/", /* Specify the root folder within your source files. */
+    "outDir": "./build/", /* Specify an output folder for all emitted files. */
+    "moduleResolution": "Bundler",
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./*.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/consts.ts","./src/errors.ts","./src/index.ts","./src/model.ts","./src/types.ts"],"version":"5.6.3"}