@ug.software/opposer 3.0.10

package/lib/esm/examples/full-app/index.js

@@ -0,0 +1,64 @@
+import Server, { Context } from '../../server/index.js';
+import Author from './models/author.js';
+import Book from './models/book.js';
+import Category from './models/category.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// @ts-ignore
+const _dirname = typeof __dirname !== 'undefined'
+    ? __dirname
+    : // @ts-ignore
+        path.dirname(fileURLToPath(import.meta.url));
+async function runFullExample() {
+    console.log('🚀 Initializing Full Opposer Example...');
+    // 1. Setup Environment
+    process.env.OPPOSER_PORT = '4000';
+    process.env.OPPOSER_DATABASE_TYPE = 'sqlite';
+    process.env.OPPOSER_DATABASE_NAME = './full-app.db';
+    try {
+        // 2. Start Opposer Server
+        // Passing the local models and schedules path so initialization can find our entities
+        const { initialize } = await Server({
+            cors: { origin: '*' },
+            models: path.resolve(_dirname, 'models'),
+            schedules: path.resolve(_dirname, 'schedules'),
+        });
+        // 3. Populate Initial Data
+        // Using the new global Context to get the database
+        const db = Context.get('db');
+        console.log('📝 Populating initial data...');
+        const authorRepo = db.getRepository(Author);
+        const categoryRepo = db.getRepository(Category);
+        const bookRepo = db.getRepository(Book);
+        //@ts-ignore
+        const { randomUUID } = await import('crypto');
+        // Insert Author
+        let author = await authorRepo.findOne({ where: { name: 'J.K. Rowling' } });
+        if (!author) {
+            author = await authorRepo.insert({ id: randomUUID(), name: 'J.K. Rowling', nationality: 'British' });
+        }
+        // Insert Category
+        let category = await categoryRepo.findOne({ where: { title: 'Fantasy' } });
+        if (!category) {
+            category = await categoryRepo.insert({ id: randomUUID(), title: 'Fantasy' });
+        }
+        // Insert Books
+        const bookCount = await bookRepo.count({});
+        if (bookCount === 0) {
+            await bookRepo.insert({ id: randomUUID(), title: "Harry Potter and the Philosopher's Stone", price: 39.9, author: author.id, category: category.id });
+            await bookRepo.insert({ id: randomUUID(), title: 'Harry Potter and the Chamber of Secrets', price: 42.5, author: author.id, category: category.id });
+            console.log('✅ Data populated.');
+        }
+        // 4. Start listening
+        initialize();
+        console.log('\n--- Example Info ---');
+        console.log('API URL: http://localhost:4000/opposer');
+        console.log('Playground Map: http://localhost:4000/opposer-map.json');
+        console.log('Playground Status: http://localhost:4000/playground');
+        console.log('--------------------\n');
+    }
+    catch (error) {
+        console.error('❌ Failed to start example:', error);
+    }
+}
+runFullExample();

package/lib/esm/examples/full-app/models/author.d.ts

@@ -0,0 +1,7 @@
+import Book from "./book.js";
+export default class Author {
+    id: string;
+    name: string;
+    nationality?: string;
+    books: Book[];
+}

package/lib/esm/examples/full-app/models/author.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, Relation, f } from "../../../orm/index.js";
+import Book from "./book.js";
+let Author = class Author {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], Author.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("Name is string").required("Name is required")),
+    __metadata("design:type", String)
+], Author.prototype, "name", void 0);
+__decorate([
+    Field({ type: "string" }),
+    __metadata("design:type", String)
+], Author.prototype, "nationality", void 0);
+__decorate([
+    Relation({
+        type: "one-to-many",
+        target: () => Book,
+        inverseSide: "author"
+    }),
+    __metadata("design:type", Array)
+], Author.prototype, "books", void 0);
+Author = __decorate([
+    Entity("authors", { description: "The author of the book, which contains the name and nationality" })
+], Author);
+export default Author;

package/lib/esm/examples/full-app/models/book.d.ts

@@ -0,0 +1,9 @@
+import Author from "./author.js";
+import Category from "./category.js";
+export default class Book {
+    id: string;
+    title: string;
+    price: number;
+    author: Author;
+    category: Category;
+}

package/lib/esm/examples/full-app/models/book.js

@@ -0,0 +1,46 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, Relation, f } from "../../../orm/index.js";
+import Author from "./author.js";
+import Category from "./category.js";
+let Book = class Book {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], Book.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("Title is string").required("Title is required")),
+    __metadata("design:type", String)
+], Book.prototype, "title", void 0);
+__decorate([
+    Field({ type: "number", default: 0 }),
+    __metadata("design:type", Number)
+], Book.prototype, "price", void 0);
+__decorate([
+    Relation({
+        type: "many-to-one",
+        target: () => Author,
+        inverseSide: "books"
+    }),
+    __metadata("design:type", Author)
+], Book.prototype, "author", void 0);
+__decorate([
+    Relation({
+        type: "many-to-one",
+        target: () => Category,
+        inverseSide: "books"
+    }),
+    __metadata("design:type", Category)
+], Book.prototype, "category", void 0);
+Book = __decorate([
+    Entity("books", { description: "Entity representing a book in the store" })
+], Book);
+export default Book;

package/lib/esm/examples/full-app/models/category.d.ts

@@ -0,0 +1,4 @@
+export default class Category {
+    id: string;
+    title: string;
+}

package/lib/esm/examples/full-app/models/category.js

@@ -0,0 +1,24 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, f } from "../../../orm/index.js";
+let Category = class Category {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], Category.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("Title is string").required("Title is required")),
+    __metadata("design:type", String)
+], Category.prototype, "title", void 0);
+Category = __decorate([
+    Entity("categories")
+], Category);
+export default Category;

package/lib/esm/examples/full-app/schedules/catalog-refresh.d.ts

@@ -0,0 +1,28 @@
+import { OpposerDatabase } from '../../../orm';
+export default class CatalogRefreshSchedules {
+    refreshCatalog(): Promise<{
+        status: string;
+        imported: number;
+        timestamp: string;
+        message?: undefined;
+    } | {
+        status: string;
+        message: any;
+        imported?: undefined;
+        timestamp?: undefined;
+    }>;
+    /**
+     * Logic to wipe and refill the catalog with 10,000 books
+     */
+    static performRefresh(db: OpposerDatabase): Promise<{
+        status: string;
+        imported: number;
+        timestamp: string;
+        message?: undefined;
+    } | {
+        status: string;
+        message: any;
+        imported?: undefined;
+        timestamp?: undefined;
+    }>;
+}

package/lib/esm/examples/full-app/schedules/catalog-refresh.js

@@ -0,0 +1,143 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Schedule } from '../../../scheduler';
+import { Context } from '../../../server';
+import Book from '../models/book.js';
+import Author from '../models/author.js';
+import Category from '../models/category.js';
+import { randomUUID } from 'crypto';
+export default class CatalogRefreshSchedules {
+    async refreshCatalog() {
+        console.log('[schedule] Starting hourly catalog refresh...');
+        const db = Context.get('db');
+        return await CatalogRefreshSchedules.performRefresh(db);
+    }
+    /**
+     * Logic to wipe and refill the catalog with 10,000 books
+     */
+    static async performRefresh(db) {
+        try {
+            const authorRepo = db.getRepository(Author);
+            const categoryRepo = db.getRepository(Category);
+            const bookRepo = db.getRepository(Book);
+            const totalToFetch = 100;
+            const pageSize = 10;
+            const pages = totalToFetch / pageSize;
+            console.log(`[catalog-refresh] Fetching ${totalToFetch} books from Open Library...`);
+            const allBooksData = [];
+            for (let i = 0; i < pages; i += 5) {
+                const requests = [];
+                for (let j = 0; j < 5 && i + j < pages; j++) {
+                    const page = i + j + 1;
+                    requests.push(fetch(`https://openlibrary.org/search.json?q=has_fulltext:true&page=${page}&limit=${pageSize}`)
+                        .then((res) => res.json())
+                        .then((data) => data.docs || [])
+                        .catch((err) => {
+                        console.error(`Error fetching page ${page}:`, err.message);
+                        return [];
+                    }));
+                }
+                const results = await Promise.all(requests);
+                allBooksData.push(...results.flat());
+                if (allBooksData.length >= totalToFetch)
+                    break;
+            }
+            console.log('allBooksData', allBooksData);
+            if (allBooksData.length === 0)
+                throw new Error('No books fetched from API');
+            console.log(`[catalog-refresh] Wiping current database...`);
+            //@ts-ignore
+            if (typeof db.query === 'function') {
+                //@ts-ignore
+                await db.query('DELETE FROM books');
+                //@ts-ignore
+                await db.query('DELETE FROM authors');
+                //@ts-ignore
+                await db.query('DELETE FROM categories');
+            }
+            else {
+                //@ts-ignore
+                if (typeof bookRepo.delete === 'function') {
+                    //@ts-ignore
+                    await bookRepo.delete({});
+                    //@ts-ignore
+                    await authorRepo.delete({});
+                    //@ts-ignore
+                    await categoryRepo.delete({});
+                }
+            }
+            const authorsMap = new Map();
+            const categoriesMap = new Map();
+            let importedCount = 0;
+            console.log(`[catalog-refresh] Processing and inserting records...`);
+            for (const bookData of allBooksData) {
+                if (!bookData.title)
+                    continue;
+                // Author
+                const authorName = (bookData.author_name && bookData.author_name[0]) || 'Unknown Author';
+                let authorId = authorsMap.get(authorName);
+                if (!authorId) {
+                    authorId = randomUUID();
+                    await authorRepo.insert({
+                        id: authorId,
+                        name: authorName,
+                        nationality: 'Unknown',
+                    });
+                    authorsMap.set(authorName, authorId);
+                }
+                // Category
+                const categoryName = (bookData.subject && bookData.subject[0]) || 'General';
+                let categoryId = categoriesMap.get(categoryName);
+                if (!categoryId) {
+                    categoryId = randomUUID();
+                    await categoryRepo.insert({
+                        id: categoryId,
+                        title: categoryName,
+                    });
+                    categoriesMap.set(categoryName, categoryId);
+                }
+                // Book
+                let imageUrl = bookData.cover_i ? `https://covers.openlibrary.org/b/id/${bookData.cover_i}-L.jpg` : undefined;
+                await bookRepo.insert({
+                    id: randomUUID(),
+                    title: bookData.title,
+                    price: Math.floor(Math.random() * 100) + 20,
+                    imageUrl,
+                    author: authorId,
+                    category: categoryId,
+                });
+                importedCount++;
+                if (importedCount % 1000 === 0)
+                    console.log(`[catalog-refresh] Imported ${importedCount} books...`);
+                if (importedCount >= totalToFetch)
+                    break;
+            }
+            console.log(`[catalog-refresh] Success! Total imported: ${importedCount}`);
+            return {
+                status: 'success',
+                imported: importedCount,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            console.error(`[catalog-refresh] Failed:`, error.message);
+            return { status: 'error', message: error.message };
+        }
+    }
+}
+__decorate([
+    Schedule({
+        name: 'hourly-catalog-wipe-and-refill',
+        interval: 3600000, // 1 hour
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CatalogRefreshSchedules.prototype, "refreshCatalog", null);

package/lib/esm/examples/full-app/schedules/inventory-sync.d.ts

@@ -0,0 +1,12 @@
+export default class InventorySchedules {
+    checkStock(): Promise<{
+        timestamp: string;
+        booksChecked: number;
+        status: string;
+    }>;
+    importCatalog(): Promise<{
+        imported: number;
+        skipped: number;
+        errors: number;
+    }>;
+}

package/lib/esm/examples/full-app/schedules/inventory-sync.js

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Schedule } from "../../../scheduler/index.js";
+import { Context } from "../../../server/index.js";
+import Book from "../models/book.js";
+export default class InventorySchedules {
+    async checkStock() {
+        // Using the new global Context to get the database
+        const db = Context.get("db");
+        const bookRepo = db.getRepository(Book);
+        const count = await bookRepo.count({});
+        console.log(`[schedule] Inventory check: ${count} books in library.`);
+        return {
+            timestamp: new Date().toISOString(),
+            booksChecked: count,
+            status: "Inventory levels are stable"
+        };
+    }
+    async importCatalog() {
+        console.log(`[schedule] Importing new titles from external partners...`);
+        // Simulate API delay
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        return {
+            imported: 12,
+            skipped: 2,
+            errors: 0
+        };
+    }
+}
+__decorate([
+    Schedule({
+        name: "library-inventory-check",
+        interval: 300000, // 5 minutes
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], InventorySchedules.prototype, "checkStock", null);
+__decorate([
+    Schedule({
+        name: "import-external-catalog",
+        interval: 3600000, // 1 hour
+        enabled: false
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], InventorySchedules.prototype, "importCatalog", null);

package/lib/esm/examples/full-app/schedules/library-alerts.d.ts

@@ -0,0 +1,11 @@
+export default class LibraryAlertSchedules {
+    checkOverdue(): Promise<{
+        overdueCount: number;
+        notificationsSent: boolean;
+    }>;
+    generateSalesReport(): Promise<{
+        reportId: string;
+        status: string;
+        path: string;
+    }>;
+}

package/lib/esm/examples/full-app/schedules/library-alerts.js

@@ -0,0 +1,52 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Schedule } from "../../../scheduler/index.js";
+export default class LibraryAlertSchedules {
+    async checkOverdue() {
+        console.log(`[schedule] Checking for overdue book loans...`);
+        // Simulating finding overdue loans
+        const found = 3;
+        if (found > 0) {
+            console.log(`[schedule] Sending ${found} notifications to readers.`);
+        }
+        return {
+            overdueCount: found,
+            notificationsSent: true
+        };
+    }
+    async generateSalesReport() {
+        console.log(`[schedule] Generating periodic sales report for authors...`);
+        // Simulation
+        const reportId = `REP-${Math.floor(Math.random() * 10000)}`;
+        return {
+            reportId,
+            status: "Report generated and available for download.",
+            path: `/reports/${reportId}.pdf`
+        };
+    }
+}
+__decorate([
+    Schedule({
+        name: "overdue-book-loans",
+        interval: 600000, // 10 minutes
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], LibraryAlertSchedules.prototype, "checkOverdue", null);
+__decorate([
+    Schedule({
+        name: "author-sales-report",
+        interval: 1800000, // 30 minutes
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], LibraryAlertSchedules.prototype, "generateSalesReport", null);

package/lib/esm/examples/minimal/src/handlers/book.d.ts

@@ -0,0 +1,11 @@
+declare class GetAllPerDateDto {
+    date: Date;
+}
+declare class GetAllBooksPerAuthorDto {
+    author: string;
+}
+export default class Books {
+    getAllBooksPerDate(filter: GetAllPerDateDto): never[];
+    getAllBooksPerAuthor(filter: GetAllBooksPerAuthorDto): void;
+}
+export {};

package/lib/esm/examples/minimal/src/handlers/book.js

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { f, Field, Controller, Method, Payload, } from "../../../../server/index.js";
+class GetAllPerDateDto {
+}
+__decorate([
+    Field(() => f().date("typeof is Date").required("date is required")),
+    __metadata("design:type", Date)
+], GetAllPerDateDto.prototype, "date", void 0);
+class GetAllBooksPerAuthorDto {
+}
+__decorate([
+    Field(() => f().string("typeof is string").required("author is required")),
+    __metadata("design:type", String)
+], GetAllBooksPerAuthorDto.prototype, "author", void 0);
+let Books = class Books {
+    getAllBooksPerDate(filter) {
+        return [];
+    }
+    getAllBooksPerAuthor(filter) { }
+};
+__decorate([
+    Method(),
+    __param(0, Payload(GetAllPerDateDto)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [GetAllPerDateDto]),
+    __metadata("design:returntype", void 0)
+], Books.prototype, "getAllBooksPerDate", null);
+__decorate([
+    Method(),
+    __param(0, Payload(GetAllBooksPerAuthorDto)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [GetAllBooksPerAuthorDto]),
+    __metadata("design:returntype", void 0)
+], Books.prototype, "getAllBooksPerAuthor", null);
+Books = __decorate([
+    Controller("books")
+], Books);
+export default Books;

package/lib/esm/examples/minimal/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/examples/minimal/src/index.js

@@ -0,0 +1,9 @@
+import Server from "../../../server/index.js";
+(async () => {
+    var app = await Server({
+        cors: {
+            origin: "*",
+        },
+    });
+    app.initialize();
+})();

package/lib/esm/examples/minimal/src/models/books.d.ts

@@ -0,0 +1,4 @@
+export default class Books {
+    id: string;
+    name: string;
+}

package/lib/esm/examples/minimal/src/models/books.js

@@ -0,0 +1,24 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, PrimaryColumn, Field, f } from "../../../../orm/index.js";
+let Books = class Books {
+};
+__decorate([
+    PrimaryColumn({ generated: true }),
+    __metadata("design:type", String)
+], Books.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("type of string").required("field is required")),
+    __metadata("design:type", String)
+], Books.prototype, "name", void 0);
+Books = __decorate([
+    Entity("book")
+], Books);
+export default Books;

package/lib/esm/examples/orm/models/permission.d.ts

@@ -0,0 +1,6 @@
+import User from "./user.js";
+export default class Permission {
+    id: string;
+    name: string;
+    user: User;
+}

package/lib/esm/examples/orm/models/permission.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, Relation } from "../../../orm/index.js";
+import User from "./user.js";
+let Permission = class Permission {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], Permission.prototype, "id", void 0);
+__decorate([
+    Field({ type: "string" }),
+    __metadata("design:type", String)
+], Permission.prototype, "name", void 0);
+__decorate([
+    Relation({
+        type: "many-to-one",
+        target: () => User,
+        inverseSide: "permissions"
+    }),
+    __metadata("design:type", User)
+], Permission.prototype, "user", void 0);
+Permission = __decorate([
+    Entity("permissions")
+], Permission);
+export default Permission;