@airoom/nextmin-node 0.1.0

package/dist/database/DatabaseAdapter.d.ts

@@ -0,0 +1,14 @@
+import { ReadOptions, Schema } from '../models/BaseModel';
+export type IndexDir = 1 | -1;
+export type FieldIndexSpec = Record<string, IndexDir>;
+export interface DatabaseAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    registerSchemas(schemas: Record<string, Schema>): Promise<void> | void;
+    create(collection: string, data: any, schemaDefinition: Schema, includePrivateFields?: boolean): Promise<any>;
+    read(collection: string, query: any, limit?: number, skip?: number, schemaDefinition?: Schema, includePrivateFields?: boolean, options?: ReadOptions): Promise<any[]>;
+    update(collection: string, id: string, data: any, schemaDefinition: Schema, includePrivateFields?: boolean): Promise<any>;
+    delete(collection: string, id: string, schemaDefinition: Schema, includePrivateFields?: boolean): Promise<any>;
+    count(collection: string, query: any, schemaDefinition: Schema, includePrivateFields?: boolean): Promise<number>;
+    syncIndexes?(modelName: string, desired: FieldIndexSpec): Promise<void>;
+}

package/dist/database/DatabaseAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/database/InMemoryAdapter.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseAdapter, FieldIndexSpec } from './DatabaseAdapter';
+import { ReadOptions, Schema } from '../models/BaseModel';
+export declare class InMemoryAdapter implements DatabaseAdapter {
+    private data;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    registerSchemas(schemas: Record<string, Schema>): void;
+    create(collection: string, data: any, schemaDefinition: Schema): Promise<any>;
+    read(collection: string, query: any, limit?: number, skip?: number, schemaDefinition?: Schema, _includePrivateFields?: boolean, _options?: ReadOptions): Promise<any[]>;
+    update(collection: string, id: string, data: any, schemaDefinition: Schema): Promise<any>;
+    delete(collection: string, id: string, schemaDefinition: Schema): Promise<any>;
+    count(collection: string, query: any, schemaDefinition: Schema): Promise<number>;
+    syncIndexes(_modelName: string, _desired: FieldIndexSpec): Promise<void>;
+    private generateId;
+}

package/dist/database/InMemoryAdapter.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryAdapter = void 0;
+class InMemoryAdapter {
+    constructor() {
+        this.data = {};
+    }
+    async connect() {
+        // No-op for in-memory
+    }
+    async disconnect() {
+        // No-op for in-memory
+    }
+    registerSchemas(schemas) {
+        // No-op for in-memory, but you could validate schemas here if needed
+    }
+    async create(collection, data, schemaDefinition) {
+        if (!this.data[collection]) {
+            this.data[collection] = [];
+        }
+        // Generate a simple id if not present
+        if (!data.id) {
+            data.id = `${Date.now()}_${Math.random()}`;
+        }
+        this.data[collection].push(data);
+        return data;
+    }
+    async read(collection, query, limit, skip, schemaDefinition, _includePrivateFields, _options) {
+        const allData = this.data[collection] || [];
+        let results = allData.filter((item) => {
+            return Object.entries(query).every(([key, value]) => item[key] === value);
+        });
+        if (limit !== undefined && skip !== undefined) {
+            results = results.slice(skip, skip + limit);
+        }
+        return results;
+    }
+    async update(collection, id, data, schemaDefinition) {
+        const allData = this.data[collection] || [];
+        const index = allData.findIndex((item) => item.id === id);
+        if (index === -1) {
+            throw new Error(`Document with id ${id} not found in collection '${collection}'`);
+        }
+        this.data[collection][index] = { ...allData[index], ...data };
+        return this.data[collection][index];
+    }
+    async delete(collection, id, schemaDefinition) {
+        const allData = this.data[collection] || [];
+        const index = allData.findIndex((item) => item.id === id);
+        if (index === -1) {
+            throw new Error(`Document with id ${id} not found in collection '${collection}'`);
+        }
+        const deleted = this.data[collection].splice(index, 1)[0];
+        return deleted;
+    }
+    async count(collection, query, schemaDefinition) {
+        const allData = this.data[collection] || [];
+        // Count documents matching the query
+        const results = allData.filter((item) => {
+            return Object.entries(query).every(([key, value]) => item[key] === value);
+        });
+        return results.length;
+    }
+    async syncIndexes(_modelName, _desired) {
+        // no-op for memory adapter
+    }
+    generateId() {
+        return Math.random().toString(36).substr(2, 9);
+    }
+}
+exports.InMemoryAdapter = InMemoryAdapter;

package/dist/database/MongoAdapter.d.ts

@@ -0,0 +1,52 @@
+import { DatabaseAdapter, FieldIndexSpec } from './DatabaseAdapter';
+import { ReadOptions, Schema as NextMinSchema } from '../models/BaseModel';
+export declare class MongoAdapter implements DatabaseAdapter {
+    private url;
+    private dbName;
+    private connection;
+    /** Map keyed by lowercased modelName (e.g., "users", "roles") → Mongoose Model */
+    private models;
+    constructor(url: string, dbName: string);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Register (and re-register) all schemas.
+     * - Drops compiled models that no longer exist.
+     * - Recompiles every current model so validators reflect latest schema.
+     */
+    registerSchemas(schemas: Record<string, NextMinSchema>): Promise<void>;
+    /** Optional hook used by the router when schemas are removed. */
+    unregisterSchemas(names: string[]): Promise<void>;
+    /** Optional single-model drop hook. */
+    dropModel(nameRaw: string): Promise<void>;
+    /**
+     * Delete a compiled model by case-insensitive match.
+     * Works whether we compiled it as "Users" or "users".
+     */
+    private safeDeleteModel;
+    private safeDropCollection;
+    /** Build a fresh Mongoose schema from our NextMin schema definition. */
+    private buildMongooseSchema;
+    private mapAttribute;
+    private mapScalar;
+    /**
+     * Resolve (or lazily create) the compiled model for a schema.
+     * Uses schema.modelName as the Mongoose model name and
+     * (schema.collection ?? modelName).toLowerCase() as the collection.
+     */
+    private getModel;
+    private getSchema;
+    private convertQueryFieldsToObjectId;
+    private toAppObject;
+    create(collection: string, data: any, schemaDefinition: NextMinSchema, includePrivateFields?: boolean): Promise<any>;
+    read(collection: string, query: any, limit: number | undefined, skip: number | undefined, schemaDefinition: NextMinSchema, includePrivateFields?: boolean, options?: ReadOptions): Promise<any[]>;
+    count(collection: string, query: any, schemaDefinition: NextMinSchema): Promise<number>;
+    update(collection: string, id: string, data: any, schemaDefinition: NextMinSchema, includePrivateFields?: boolean): Promise<any>;
+    delete(collection: string, id: string, schemaDefinition: NextMinSchema, includePrivateFields?: boolean): Promise<any>;
+    private getNativeCollectionByModelName;
+    /** Create/drop single-field indexes based on schema plan.
+     *  Only touches indexes named with the prefix below (won't touch user indexes).
+     */
+    private managedIndexName;
+    syncIndexes(modelName: string, desired: FieldIndexSpec): Promise<void>;
+}

package/dist/database/MongoAdapter.js

@@ -0,0 +1,409 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoAdapter = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const mongoose_autopopulate_1 = __importDefault(require("mongoose-autopopulate"));
+const Logger_1 = __importDefault(require("../utils/Logger"));
+const SchemaLoader_1 = require("../utils/SchemaLoader");
+// Prevent Mongoose from pluralizing model names automatically
+mongoose_1.default.pluralize(null);
+class MongoAdapter {
+    constructor(url, dbName) {
+        this.url = url;
+        this.dbName = dbName;
+        this.connection = mongoose_1.default.createConnection(`${this.url}/${this.dbName}`);
+        this.models = new Map();
+    }
+    async connect() {
+        await this.connection.asPromise();
+        Logger_1.default.info('MongoAdapter', `Connected to MongoDB database: ${this.dbName}`);
+    }
+    async disconnect() {
+        await this.connection.close();
+        Logger_1.default.warn('MongoAdapter', 'Disconnected from MongoDB database');
+    }
+    /**
+     * Register (and re-register) all schemas.
+     * - Drops compiled models that no longer exist.
+     * - Recompiles every current model so validators reflect latest schema.
+     */
+    async registerSchemas(schemas) {
+        // Build the incoming set from schema.modelName (not object keys!)
+        const incoming = new Set(Object.values(schemas).map((s) => s.modelName.toLowerCase()));
+        // 1) Remove compiled models that are no longer present
+        for (const name of Array.from(this.models.keys())) {
+            if (!incoming.has(name)) {
+                this.safeDeleteModel(name);
+                this.models.delete(name);
+                // Optional: also drop the collection (disabled by default)
+                // await this.safeDropCollection(name);
+            }
+        }
+        // 2) (Re)compile every current model so validators and fields are fresh
+        for (const def of Object.values(schemas)) {
+            const modelKey = def.modelName; // e.g. "Users"
+            const modelKeyLc = modelKey.toLowerCase();
+            const collection = def.collection?.toLowerCase() ?? modelKeyLc; // e.g. "users"
+            // always delete previous compiled model to avoid OverwriteModelError and stale validators
+            this.safeDeleteModel(modelKey);
+            const mSchema = this.buildMongooseSchema(def);
+            const model = this.connection.model(modelKey, mSchema, collection);
+            this.models.set(modelKeyLc, model);
+        }
+    }
+    /** Optional hook used by the router when schemas are removed. */
+    async unregisterSchemas(names) {
+        for (const raw of names) {
+            const lc = raw.toLowerCase();
+            this.safeDeleteModel(lc);
+            this.models.delete(lc);
+            // Optional: await this.safeDropCollection(lc);
+        }
+    }
+    /** Optional single-model drop hook. */
+    async dropModel(nameRaw) {
+        const lc = nameRaw.toLowerCase();
+        this.safeDeleteModel(lc);
+        this.models.delete(lc);
+        // Optional: await this.safeDropCollection(lc);
+    }
+    // ---------------- Internals ----------------
+    /**
+     * Delete a compiled model by case-insensitive match.
+     * Works whether we compiled it as "Users" or "users".
+     */
+    safeDeleteModel(nameOrLc) {
+        try {
+            const targetLc = nameOrLc.toLowerCase();
+            const keys = Object.keys(this.connection.models);
+            for (const k of keys) {
+                if (k.toLowerCase() === targetLc) {
+                    this.connection.deleteModel(k);
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    async safeDropCollection(name) {
+        try {
+            await this.connection.dropCollection(name);
+        }
+        catch (e) {
+            // ignore "ns not found" etc.
+            if (e?.codeName !== 'NamespaceNotFound') {
+                Logger_1.default.warn('MongoAdapter', `dropCollection(${name}) warning:`, e?.message || e);
+            }
+        }
+    }
+    /** Build a fresh Mongoose schema from our NextMin schema definition. */
+    buildMongooseSchema(def) {
+        const shape = {};
+        for (const [key, attr] of Object.entries(def.attributes)) {
+            shape[key] = this.mapAttribute(attr);
+        }
+        const s = new mongoose_1.Schema(shape, { timestamps: true });
+        // Hide private fields by default when toObject() is used (unless overridden)
+        s.set('toObject', {
+            transform: (_doc, ret) => {
+                for (const [key, attr] of Object.entries(def.attributes)) {
+                    if (!Array.isArray(attr) && attr.private) {
+                        delete ret[key];
+                    }
+                }
+                return ret;
+            },
+        });
+        s.plugin(mongoose_autopopulate_1.default);
+        return s;
+    }
+    mapAttribute(attribute) {
+        // Arrays
+        if (Array.isArray(attribute)) {
+            const elem = attribute[0] || { type: 'string' };
+            const mapped = this.mapScalar(elem);
+            // Mongoose "array of refs" works best as [{ type: X, ref: 'Y', autopopulate: true }]
+            const arrItem = { ...mapped };
+            // required belongs on the path, not the inner type
+            const required = !!elem.required;
+            delete arrItem.required;
+            return { type: [arrItem], required };
+        }
+        // Single
+        return this.mapScalar(attribute);
+    }
+    mapScalar(attr) {
+        const typeMapping = {
+            string: String,
+            number: Number,
+            boolean: Boolean,
+            date: Date,
+            array: Array,
+            object: Object,
+            objectid: mongoose_1.default.Schema.Types.ObjectId,
+        };
+        const out = {
+            type: typeMapping[String(attr?.type || 'string').toLowerCase()] || String,
+        };
+        // Only set when truthy to avoid forcing behavior when unset
+        if (attr?.required === true)
+            out.required = true;
+        if (attr?.unique === true)
+            out.unique = true;
+        if (attr?.ref) {
+            out.ref = attr.ref;
+            out.autopopulate = true;
+        }
+        if (attr?.default !== undefined) {
+            if (String(attr.type).toLowerCase() === 'date' &&
+                attr.default === 'now') {
+                out.default = Date.now;
+            }
+            else {
+                out.default = attr.default;
+            }
+        }
+        // Optional common validators
+        if (attr?.enum)
+            out.enum = attr.enum;
+        if (attr?.min !== undefined)
+            out.min = attr.min;
+        if (attr?.max !== undefined)
+            out.max = attr.max;
+        if (attr?.minLength !== undefined)
+            out.minLength = attr.minLength;
+        if (attr?.maxLength !== undefined)
+            out.maxLength = attr.maxLength;
+        if (attr?.match)
+            out.match = new RegExp(attr.match);
+        return out;
+    }
+    /**
+     * Resolve (or lazily create) the compiled model for a schema.
+     * Uses schema.modelName as the Mongoose model name and
+     * (schema.collection ?? modelName).toLowerCase() as the collection.
+     */
+    getModel(collection, schemaDefinition) {
+        const modelKey = schemaDefinition.modelName; // e.g. "Users"
+        const modelKeyLc = modelKey.toLowerCase();
+        const collectionName = schemaDefinition.collection?.toLowerCase() ??
+            collection.toLowerCase();
+        // Prefer cached by lowercased model key
+        const cached = this.models.get(modelKeyLc);
+        if (cached)
+            return cached;
+        // Ensure any dependency (rare) – preserved from your original example
+        if (schemaDefinition.attributes.author?.ref === 'Users') {
+            const userSchema = this.getSchema('Users');
+            if (!userSchema)
+                throw new Error(`Missing schema for Users`);
+            if (!this.models.has('users')) {
+                const uModel = this.connection.model(userSchema.modelName, this.buildMongooseSchema(userSchema), userSchema.collection?.toLowerCase() ??
+                    userSchema.modelName.toLowerCase());
+                this.models.set('users', uModel);
+            }
+        }
+        // Remove any stale compiled model(s) with same name (case-insensitive), then (re)create
+        this.safeDeleteModel(modelKey);
+        const model = this.connection.model(modelKey, this.buildMongooseSchema(schemaDefinition), collectionName);
+        this.models.set(modelKeyLc, model);
+        return model;
+    }
+    getSchema(modelName) {
+        // Use the singleton loader so we read the same live map as the router
+        const loader = SchemaLoader_1.SchemaLoader.getInstance?.() ?? new SchemaLoader_1.SchemaLoader();
+        const schemas = loader.getSchemas();
+        // The loader returns a map keyed by modelName; prefer lookup by value
+        const byName = Object.values(schemas).find((s) => String(s.modelName).toLowerCase() === modelName.toLowerCase());
+        return byName;
+    }
+    convertQueryFieldsToObjectId(query, schemaDefinition) {
+        const newQuery = { ...query };
+        // Remap 'id' to '_id'
+        if (newQuery.id !== undefined) {
+            try {
+                newQuery._id = new mongoose_1.default.Types.ObjectId(String(newQuery.id));
+            }
+            catch {
+                // leave as-is if not a valid ObjectId
+                newQuery._id = newQuery.id;
+            }
+            delete newQuery.id;
+        }
+        // Convert any fields defined as objectid
+        for (const [key, attribute] of Object.entries(schemaDefinition.attributes)) {
+            if (!Array.isArray(attribute) &&
+                String(attribute.type || '').toLowerCase() === 'objectid') {
+                const val = newQuery[key];
+                if (val === undefined || val === null)
+                    continue;
+                const toObjectId = (v) => {
+                    try {
+                        return new mongoose_1.default.Types.ObjectId(String(v));
+                    }
+                    catch {
+                        Logger_1.default.warn('MongoAdapter', `Invalid ObjectId for '${key}': ${v}`);
+                        return v;
+                    }
+                };
+                if (Array.isArray(val)) {
+                    newQuery[key] = val.map(toObjectId);
+                }
+                else {
+                    newQuery[key] = toObjectId(val);
+                }
+            }
+        }
+        return newQuery;
+    }
+    toAppObject(doc, includePrivateFields) {
+        if (!doc)
+            return doc;
+        const obj = doc.toObject(includePrivateFields
+            ? { transform: (_doc, ret) => ret } // override to keep private fields
+            : undefined);
+        if (obj?._id !== undefined) {
+            obj.id = String(obj._id);
+            delete obj._id;
+        }
+        if ('__v' in obj)
+            delete obj.__v;
+        return obj;
+    }
+    // ---------------- CRUD ----------------
+    async create(collection, data, schemaDefinition, includePrivateFields = false) {
+        const model = this.getModel(collection, schemaDefinition);
+        const doc = new model(data);
+        const saved = await doc.save();
+        return this.toAppObject(saved, includePrivateFields);
+    }
+    async read(collection, query, limit, skip, schemaDefinition, includePrivateFields, options) {
+        const model = this.getModel(collection, schemaDefinition);
+        const q = this.convertQueryFieldsToObjectId(query, schemaDefinition);
+        let cursor = model.find(q, options?.projection); // ✅ projection support (optional)
+        if (options?.sort && Object.keys(options.sort).length) {
+            cursor = cursor.sort(options.sort); // ✅ apply sort
+        }
+        if (limit !== undefined && skip !== undefined) {
+            cursor = cursor.limit(limit).skip(skip);
+        }
+        const results = await cursor.exec();
+        return results.map((doc) => this.toAppObject(doc, includePrivateFields));
+    }
+    async count(collection, query, schemaDefinition) {
+        const model = this.getModel(collection, schemaDefinition);
+        const q = this.convertQueryFieldsToObjectId(query, schemaDefinition);
+        return model.countDocuments(q).exec();
+    }
+    async update(collection, id, data, schemaDefinition, includePrivateFields) {
+        const model = this.getModel(collection, schemaDefinition);
+        const { _id } = this.convertQueryFieldsToObjectId({ id }, schemaDefinition);
+        const updated = await model
+            .findByIdAndUpdate(_id, data, { new: true, runValidators: true })
+            .exec();
+        if (!updated) {
+            throw new Error(`Document with id ${id} not found in collection '${collection}'`);
+        }
+        return this.toAppObject(updated, includePrivateFields);
+    }
+    async delete(collection, id, schemaDefinition, includePrivateFields = false) {
+        const model = this.getModel(collection, schemaDefinition);
+        const { _id } = this.convertQueryFieldsToObjectId({ id }, schemaDefinition);
+        const deleted = await model.findByIdAndDelete(_id).exec();
+        if (!deleted) {
+            throw new Error(`Document with id ${id} not found in collection '${collection}'`);
+        }
+        return this.toAppObject(deleted, includePrivateFields);
+    }
+    getNativeCollectionByModelName(modelName) {
+        const s = this.getSchema(modelName);
+        if (!s)
+            throw new Error(`Schema not found for ${modelName}`);
+        const collName = s.collection?.toLowerCase?.() ?? s.modelName.toLowerCase();
+        // returns the MongoDB driver's Collection (not a Mongoose Model)
+        return this.connection.collection(collName);
+    }
+    /** Create/drop single-field indexes based on schema plan.
+     *  Only touches indexes named with the prefix below (won't touch user indexes).
+     */
+    managedIndexName(field) {
+        return `nextmin_idx_${field}`;
+    }
+    async syncIndexes(modelName, desired) {
+        const col = this.getNativeCollectionByModelName(modelName);
+        // list existing and pick only the ones we manage
+        const existing = await col.indexes();
+        const managed = new Map();
+        for (const ix of existing) {
+            const name = String(ix.name || '');
+            if (name.startsWith('nextmin_idx_')) {
+                managed.set(name, { key: ix.key });
+            }
+        }
+        // desired names from spec
+        const desiredEntries = Object.entries(desired);
+        const desiredNames = new Set(desiredEntries.map(([field]) => this.managedIndexName(field)));
+        // create / recreate if needed
+        for (const [field, dir] of desiredEntries) {
+            const name = this.managedIndexName(field);
+            const have = managed.get(name);
+            const wantKey = { [field]: dir };
+            if (!have || JSON.stringify(have.key) !== JSON.stringify(wantKey)) {
+                if (have) {
+                    try {
+                        await col.dropIndex(name);
+                    }
+                    catch { }
+                }
+                await col.createIndex(wantKey, { name, background: true });
+            }
+        }
+        // drop stale managed indexes
+        for (const name of managed.keys()) {
+            if (!desiredNames.has(name)) {
+                try {
+                    await col.dropIndex(name);
+                }
+                catch { }
+            }
+        }
+    }
+}
+exports.MongoAdapter = MongoAdapter;

package/dist/files/FileStorageAdapter.d.ts

@@ -0,0 +1,35 @@
+export type FileProvider = 's3' | 'gcs' | 'local' | (string & {});
+export interface UploadPayload {
+    /** Path-like key inside bucket/provider, e.g. "uploads/userId/2025/08/18/file.png" */
+    key?: string;
+    /** Raw file content */
+    body: Buffer | Uint8Array | ArrayBuffer;
+    /** MIME type */
+    contentType?: string;
+    /** Arbitrary metadata */
+    metadata?: Record<string, string>;
+}
+export interface UploadResult {
+    provider: FileProvider;
+    /** Provider bucket/container if applicable */
+    bucket?: string;
+    /** Final key used for storage */
+    key: string;
+    /** Public (or CDN) URL if available; otherwise a standard provider URL */
+    url: string;
+    etag?: string;
+    contentType?: string;
+    size?: number;
+    metadata?: Record<string, string>;
+}
+/** Pluggable storage provider interface (S3 now; GCS/local later) */
+export interface FileStorageAdapter {
+    readonly name: FileProvider;
+    upload(input: UploadPayload): Promise<UploadResult>;
+    delete(key: string): Promise<{
+        deleted: boolean;
+    }>;
+    /** Optional helpers */
+    getPublicUrl?(key: string): string | null;
+    getSignedUrl?(key: string, expiresInSeconds?: number): Promise<string>;
+}

package/dist/files/FileStorageAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/files/S3FileStorageAdapter.d.ts

@@ -0,0 +1,30 @@
+import type { FileStorageAdapter, UploadPayload, UploadResult } from './FileStorageAdapter';
+export interface S3AdapterOptions {
+    bucket: string;
+    region: string;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    endpoint?: string;
+    forcePathStyle?: boolean;
+    defaultACL?: 'private' | 'public-read';
+    publicBaseUrl?: string;
+}
+export declare class S3FileStorageAdapter implements FileStorageAdapter {
+    readonly name: "s3";
+    private readonly s3;
+    private readonly bucket;
+    private readonly regionStr;
+    private readonly endpoint?;
+    private readonly forcePathStyle;
+    private readonly defaultACL?;
+    private readonly publicBaseUrl?;
+    constructor(opts: S3AdapterOptions);
+    upload(input: UploadPayload): Promise<UploadResult>;
+    delete(key: string): Promise<{
+        deleted: boolean;
+    }>;
+    getPublicUrl(key: string): string;
+    private randomKey;
+}