@ug.software/opposer 3.0.10

package/lib/bin/commands/init.js

@@ -0,0 +1,169 @@
+import fs from 'fs';
+import path from 'path';
+
+export const command = "init";
+export const desc = "Scaffold a new Opposer project structure.";
+
+export const builder = {};
+
+export const handler = async () => {
+  const root = process.cwd();
+  
+  // 1. Create Directories
+  const dirs = [
+    'src',
+    'src/controllers',
+    'src/models',
+    'src/schedules'
+  ];
+
+  console.log('--> Creating project structure...');
+  
+  dirs.forEach(dir => {
+    const fullPath = path.join(root, dir);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+      console.log(`   --> Created ${dir}/`);
+    } else {
+      console.log(`   --> Skipped ${dir}/ (already exists)`);
+    }
+  });
+
+  // 2. Create Files Content
+  
+  // src/index.ts
+  const indexTsContent = `import { Server } from "@ug.software/opposer";
+
+const app = await Server({
+    models: "./src/models",
+    controllers: "./src/controllers",
+    schedules: "./src/schedules",
+    cors: { origin: "*" }
+});
+
+app.initialize();
+`;
+
+  // src/controllers/health.ts
+  const healthControllerContent = `import { Controller, Method, Success, IsPublicMethod } from "@ug.software/opposer/server";
+
+@Controller("health")
+export default class HealthController {
+    @IsPublicMethod()
+    @Method()
+    check() {
+        return Success({ 
+            status: "online", 
+            timestamp: new Date() 
+        });
+    }
+}
+`;
+
+  // src/models/example.ts
+  const exampleModelContent = `import { Entity, PrimaryColumn, Field, f, CreateDateColumn } from "@ug.software/opposer/orm";
+
+@Entity("examples", "Example Entity")
+export default class Example {
+    @PrimaryColumn({ type: "uuid" })
+    id!: string;
+
+    @Field(() => f().string().required())
+    name!: string;
+
+    @CreateDateColumn()
+    createdAt!: Date;
+}
+`;
+
+  // opposer-settings.json
+  const settingsContent = `{
+  "port": 3838,
+  "url": "/opposer",
+  "database": {
+    "type": "sqlite",
+    "database": "./database.sqlite",
+    "logging": true
+  },
+  "auth": false,
+  "logger": true
+}`;
+
+  // .env
+  const envContent = `# --- Server ---
+OPPOSER_PORT=3838
+
+# --- Database ---
+# Options: postgres, mysql, sqlite
+OPPOSER_DATABASE_TYPE=sqlite
+# For SQLite use path (e.g., ./db.sqlite), for others use DB name
+OPPOSER_DATABASE_NAME=./database.sqlite
+OPPOSER_DATABASE_LOGGING=true
+
+# DB Connection (Not needed for SQLite)
+# OPPOSER_DATABASE_HOST=localhost
+# OPPOSER_DATABASE_PORT=5432
+# OPPOSER_DATABASE_USER=root
+# OPPOSER_DATABASE_PASSWORD=secret
+
+# --- Security & Auth ---
+# Set to 'true' in settings.json or enable via code to use
+# OPPOSER_JWT_ACCESS=generate-secure-random-key-here
+# OPPOSER_JWT_REFRESH=generate-secure-random-key-here
+
+# Initial Admin User
+# OPPOSER_MANAGER_LOGIN=admin
+# OPPOSER_MANAGER_PASSWORD=admin
+# OPPOSER_MANAGER_FIRST_NAME=System
+# OPPOSER_MANAGER_LAST_NAME=Admin
+`;
+
+  // 3. Write Files
+  const files = [
+    { path: 'src/index.ts', content: indexTsContent },
+    { path: 'src/controllers/health.ts', content: healthControllerContent },
+    { path: 'src/models/example.ts', content: exampleModelContent },
+    { path: 'opposer-settings.json', content: settingsContent },
+    { path: '.env', content: envContent }
+  ];
+
+  files.forEach(file => {
+    const fullPath = path.join(root, file.path);
+    if (!fs.existsSync(fullPath)) {
+      fs.writeFileSync(fullPath, file.content);
+      console.log(`   --> Created ${file.path}`);
+    } else {
+      console.log(`   --> Skipped ${file.path} (already exists)`);
+    }
+  });
+
+  // 4. Update package.json
+  const packageJsonPath = path.join(root, 'package.json');
+  let packageJson = {};
+
+  if (fs.existsSync(packageJsonPath)) {
+    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  } else {
+    packageJson = {
+      name: path.basename(root),
+      version: "1.0.0",
+      type: "module",
+      description: "Opposer project",
+      main: "src/index.ts",
+      dependencies: {},
+      devDependencies: {}
+    };
+  }
+
+  packageJson.scripts = {
+    ...(packageJson.scripts || {}),
+    "dev": "npx tsx src/index.ts",
+    "build": "npx opposer build"
+  };
+
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  console.log('   --> Updated package.json with "dev" and "build" scripts.');
+
+  console.log('\n--> Project initialized successfully!');
+  console.log('--> Run "npm run dev" to start your server.');
+};

package/lib/bin/helpers/crypto.js

@@ -0,0 +1,33 @@
+import crypto from "crypto";
+
+function base64UrlEncode(buffer) {
+  return buffer
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "")
+    .slice(0, 200);
+}
+
+function deterministic(
+  phrase,
+  salt,
+  bytes = 32,
+  iterations = 100_000,
+  digest = "sha256"
+) {
+  const derived = crypto.pbkdf2Sync(
+    phrase,
+    crypto.randomBytes(salt),
+    bytes,
+    iterations,
+    digest
+  );
+  return base64UrlEncode(derived);
+}
+
+function hash(bytes = 32) {
+  return crypto.randomBytes(bytes).toString("hex");
+}
+
+export { deterministic, hash };

package/lib/bin/opposer.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+import * as generateJwtKey from "./commands/generate/jwt-key.js";
+import * as generateApiKey from "./commands/generate/api-key.js";
+import * as init from "./commands/init.js";
+import * as build from "./commands/build.js";
+
+yargs(hideBin(process.argv))
+  .scriptName("opposer")
+  .usage("$0 <cmd> [args]")
+  .command(init)
+  .command(build)
+  .command(generateJwtKey)
+  .command(generateApiKey)
+  .demandCommand(
+    1,
+    "É necessário informar um comando. Use --help para listar todos."
+  )
+  .strict()
+  .help()
+  .alias("h", "help")
+  .alias("v", "version")
+  .wrap(null)
+  .parse();

package/lib/cjs/examples/full-app/index.d.ts

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

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

@@ -0,0 +1,102 @@
+"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 });
+const index_js_1 = __importStar(require("../../server/index.js"));
+const author_js_1 = __importDefault(require("./models/author.js"));
+const book_js_1 = __importDefault(require("./models/book.js"));
+const category_js_1 = __importDefault(require("./models/category.js"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+// @ts-ignore
+const _dirname = typeof __dirname !== 'undefined'
+    ? __dirname
+    : // @ts-ignore
+        path_1.default.dirname((0, url_1.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 (0, index_js_1.default)({
+            cors: { origin: '*' },
+            models: path_1.default.resolve(_dirname, 'models'),
+            schedules: path_1.default.resolve(_dirname, 'schedules'),
+        });
+        // 3. Populate Initial Data
+        // Using the new global Context to get the database
+        const db = index_js_1.Context.get('db');
+        console.log('📝 Populating initial data...');
+        const authorRepo = db.getRepository(author_js_1.default);
+        const categoryRepo = db.getRepository(category_js_1.default);
+        const bookRepo = db.getRepository(book_js_1.default);
+        //@ts-ignore
+        const { randomUUID } = await Promise.resolve().then(() => __importStar(require('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/cjs/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/cjs/examples/full-app/models/author.js

@@ -0,0 +1,42 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../../orm/index.js");
+const book_js_1 = __importDefault(require("./book.js"));
+let Author = class Author {
+};
+__decorate([
+    (0, index_js_1.PrimaryColumn)({ type: "uuid" }),
+    __metadata("design:type", String)
+], Author.prototype, "id", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().string("Name is string").required("Name is required")),
+    __metadata("design:type", String)
+], Author.prototype, "name", void 0);
+__decorate([
+    (0, index_js_1.Field)({ type: "string" }),
+    __metadata("design:type", String)
+], Author.prototype, "nationality", void 0);
+__decorate([
+    (0, index_js_1.Relation)({
+        type: "one-to-many",
+        target: () => book_js_1.default,
+        inverseSide: "author"
+    }),
+    __metadata("design:type", Array)
+], Author.prototype, "books", void 0);
+Author = __decorate([
+    (0, index_js_1.Entity)("authors", { description: "The author of the book, which contains the name and nationality" })
+], Author);
+exports.default = Author;

package/lib/cjs/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/cjs/examples/full-app/models/book.js

@@ -0,0 +1,51 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../../orm/index.js");
+const author_js_1 = __importDefault(require("./author.js"));
+const category_js_1 = __importDefault(require("./category.js"));
+let Book = class Book {
+};
+__decorate([
+    (0, index_js_1.PrimaryColumn)({ type: "uuid" }),
+    __metadata("design:type", String)
+], Book.prototype, "id", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().string("Title is string").required("Title is required")),
+    __metadata("design:type", String)
+], Book.prototype, "title", void 0);
+__decorate([
+    (0, index_js_1.Field)({ type: "number", default: 0 }),
+    __metadata("design:type", Number)
+], Book.prototype, "price", void 0);
+__decorate([
+    (0, index_js_1.Relation)({
+        type: "many-to-one",
+        target: () => author_js_1.default,
+        inverseSide: "books"
+    }),
+    __metadata("design:type", author_js_1.default)
+], Book.prototype, "author", void 0);
+__decorate([
+    (0, index_js_1.Relation)({
+        type: "many-to-one",
+        target: () => category_js_1.default,
+        inverseSide: "books"
+    }),
+    __metadata("design:type", category_js_1.default)
+], Book.prototype, "category", void 0);
+Book = __decorate([
+    (0, index_js_1.Entity)("books", { description: "Entity representing a book in the store" })
+], Book);
+exports.default = Book;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../../../orm/index.js");
+let Category = class Category {
+};
+__decorate([
+    (0, index_js_1.PrimaryColumn)({ type: "uuid" }),
+    __metadata("design:type", String)
+], Category.prototype, "id", void 0);
+__decorate([
+    (0, index_js_1.Field)(() => (0, index_js_1.f)().string("Title is string").required("Title is required")),
+    __metadata("design:type", String)
+], Category.prototype, "title", void 0);
+Category = __decorate([
+    (0, index_js_1.Entity)("categories")
+], Category);
+exports.default = Category;

package/lib/cjs/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/cjs/examples/full-app/schedules/catalog-refresh.js

@@ -0,0 +1,149 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const scheduler_1 = require("../../../scheduler");
+const server_1 = require("../../../server");
+const book_js_1 = __importDefault(require("../models/book.js"));
+const author_js_1 = __importDefault(require("../models/author.js"));
+const category_js_1 = __importDefault(require("../models/category.js"));
+const crypto_1 = require("crypto");
+class CatalogRefreshSchedules {
+    async refreshCatalog() {
+        console.log('[schedule] Starting hourly catalog refresh...');
+        const db = server_1.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_js_1.default);
+            const categoryRepo = db.getRepository(category_js_1.default);
+            const bookRepo = db.getRepository(book_js_1.default);
+            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 = (0, crypto_1.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 = (0, crypto_1.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: (0, crypto_1.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 };
+        }
+    }
+}
+exports.default = CatalogRefreshSchedules;
+__decorate([
+    (0, scheduler_1.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/cjs/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;
+    }>;
+}