neosqlite 1.0.0

package/lib/src/jobs/index.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeosqliteJobs = void 0;
+const cron_parser_1 = __importDefault(require("cron-parser"));
+const chrono_node_1 = require("chrono-node");
+const client_1 = require("../client");
+const util_1 = require("../client/util");
+const types_1 = require("../types");
+class NeosqliteJobs {
+    constructor(options) {
+        this.jobsRegistry = {};
+        // Jobs worker information
+        this.activeJobs = 0;
+        this.isRunning = false;
+        this.options = options;
+        this.db = (0, client_1.createClient)(options);
+    }
+    get jobsTable() {
+        return this.options.jobsTable ?? "jobs";
+    }
+    get maxJobs() {
+        return this.options.maxJobs ?? 10;
+    }
+    get processEvery() {
+        return this.options.processEvery ?? 5000;
+    }
+    get maxRetries() {
+        return this.options.maxRetries ?? 3;
+    }
+    /**
+     * Setup tables and start the job worker for neosqlite jobs
+     */
+    async start() {
+        await this.setupTables();
+        await this.setupJobWorker();
+    }
+    /**
+     * Stop the job worker from listening for jobs
+     */
+    async stop() {
+        this.isRunning = false;
+    }
+    /**
+     * Register a job to be run
+     */
+    register(name, options, fn, onFailure) {
+        this.jobsRegistry[name] = { name, options, fn, onFailure };
+    }
+    /**
+     * Queue a job to run instantly based on its
+     * priority
+     */
+    async queue(name, data) {
+        const job = this.jobsRegistry[name];
+        if (!job)
+            return console.error(`Job ${name} does not exist`);
+        this.db.write({
+            sql: (0, util_1.queryString)("INSERT INTO " + this.jobsTable, "(name, data, runAt, priority)", "VALUES (:name, :data, CURRENT_TIMESTAMP, :priority)"),
+            args: {
+                name: job.name,
+                priority: job.options.priority ?? 0,
+                data: data ? JSON.stringify(data) : null,
+            },
+        });
+    }
+    /**
+     * Schedule a job to run in the future. This can use a date string, or a human-readable string
+     * such as 'in 10 minutes' or 'next week'
+     */
+    async schedule(date, name, data) {
+        const job = this.jobsRegistry[name];
+        if (!job)
+            return console.error(`Job ${name} does not exist`);
+        const parsedDate = (0, chrono_node_1.parseDate)(date);
+        if (!parsedDate)
+            return;
+        this.db.write({
+            sql: (0, util_1.queryString)("INSERT INTO " + this.jobsTable, "(name, data, runAt, priority)", "VALUES (:name, :data, :runAt, :priority)"),
+            args: {
+                name: job.name,
+                priority: job.options.priority ?? 0,
+                data: data ? JSON.stringify(data) : null,
+                runAt: (0, util_1.toSqliteDateString)(parsedDate),
+            },
+        });
+    }
+    /**
+     * Schedule a job to run every time the cron string is met
+     */
+    async every(cronString, name, data) {
+        const job = this.jobsRegistry[name];
+        if (!job)
+            return console.error(`Job ${name} does not exist`);
+        const interval = cron_parser_1.default.parse(cronString);
+        const runAt = interval.next().toDate();
+        this.db.write({
+            sql: (0, util_1.queryString)("INSERT OR IGNORE INTO " + this.jobsTable, "(name, data, runAt, priority, cron)", "VALUES (:name, :data, :runAt, :priority, :cron)"),
+            args: {
+                name: job.name,
+                priority: job.options.priority ?? 0,
+                data: data ? JSON.stringify(data) : null,
+                runAt: (0, util_1.toSqliteDateString)(runAt),
+                cron: cronString,
+            },
+        });
+    }
+    /**
+     * Creates the jobs table and sets up indexes on it
+     */
+    async setupTables() {
+        const jobStatuses = Object.values(types_1.JobStatus)
+            .map((s) => `'${s}'`)
+            .join(", ");
+        this.db.write((0, util_1.queryString)("CREATE TABLE IF NOT EXISTS " + this.jobsTable + " (", "  id INTEGER PRIMARY KEY AUTOINCREMENT,", "  name TEXT NOT NULL,", "  data TEXT,", "  runAt DATETIME NOT NULL,", "  priority INTEGER DEFAULT 0,", "  cron TEXT,", "  attempts INTEGER DEFAULT 0,", "  status TEXT CHECK (status IN ( " + jobStatuses + ")) DEFAULT '" + types_1.JobStatus.Pending + "',", "  updatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,", "  createdAt DATETIME DEFAULT CURRENT_TIMESTAMP", ")"));
+        // Prevent multiple cron jobs from getting scheduled for the same dates
+        this.db.write(`CREATE UNIQUE INDEX IF NOT EXISTS idx_${this.jobsTable}_name_cron_runAt ON ${this.jobsTable} (name, cron, runAt)`);
+        this.db.write(`CREATE INDEX IF NOT EXISTS idx_${this.jobsTable}_status_runAt_priority ON ${this.jobsTable} (status, runAt, priority DESC)`);
+    }
+    /**
+     * Sets up the jobs worker to run automatically
+     */
+    async setupJobWorker() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        const loop = async () => {
+            if (!this.isRunning)
+                return;
+            try {
+                if (this.activeJobs < this.maxJobs) {
+                    const limit = this.maxJobs - this.activeJobs;
+                    const rows = this.db.writeReturning({
+                        sql: (0, util_1.queryString)("UPDATE jobs", "SET status = :runningStatus,", "  attempts = attempts + 1,", "  updatedAt = CURRENT_TIMESTAMP", "WHERE id IN (", "  SELECT id", "  FROM jobs", "  WHERE status = :pendingStatus", "    AND runAt <= CURRENT_TIMESTAMP", "  ORDER BY priority DESC, runAt ASC", "  LIMIT :limit", ")", "RETURNING *"),
+                        args: {
+                            limit,
+                            pendingStatus: types_1.JobStatus.Pending,
+                            runningStatus: types_1.JobStatus.Running,
+                        },
+                    });
+                    for (const row of rows) {
+                        this.activeJobs++;
+                        this.processJob(row).finally(() => {
+                            this.activeJobs--;
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+            setTimeout(loop, this.processEvery);
+        };
+        loop();
+    }
+    async processJob(row) {
+        const id = Number(row["id"]);
+        const name = String(row["name"]);
+        const attempts = Number(row["attempts"]);
+        const cron = row["cron"] ? String(row["cron"]) : null;
+        const data = row["data"] ? (0, util_1.Jsonify)(String(row["data"])) : null;
+        const job = this.jobsRegistry[name];
+        if (!job)
+            return;
+        try {
+            await Promise.resolve(job.fn(data));
+            this.db.write({
+                sql: (0, util_1.queryString)("UPDATE " + this.jobsTable, "SET status = :status, updatedAt = CURRENT_TIMESTAMP", "WHERE id = :id"),
+                args: { id, status: types_1.JobStatus.Completed },
+            });
+            // If this is a cronjob, schedule the next run
+            if (cron) {
+                const interval = cron_parser_1.default.parse(cron);
+                const nextRun = interval.next().toDate();
+                this.db.write({
+                    sql: (0, util_1.queryString)("INSERT OR IGNORE INTO " + this.jobsTable, "(name, data, runAt, priority, cron)", "VALUES (:name, :data, :runAt, :priority, :cron)"),
+                    args: {
+                        cron,
+                        name: job.name,
+                        priority: job.options.priority ?? 0,
+                        data: data ? JSON.stringify(data) : null,
+                        runAt: (0, util_1.toSqliteDateString)(nextRun),
+                    },
+                });
+            }
+        }
+        catch (err) {
+            const updatedStatus = attempts >= this.maxRetries ? types_1.JobStatus.Failed : types_1.JobStatus.Pending;
+            this.db.write({
+                sql: (0, util_1.queryString)("UPDATE " + this.jobsTable, "SET status = :status, updatedAt = CURRENT_TIMESTAMP", "WHERE id = :id"),
+                args: { id, status: updatedStatus },
+            });
+            if (updatedStatus === types_1.JobStatus.Failed && job.onFailure) {
+                await Promise.resolve(job.onFailure(err));
+            }
+        }
+    }
+}
+exports.NeosqliteJobs = NeosqliteJobs;

package/lib/src/migrations/commands/down.d.ts

@@ -0,0 +1,2 @@
+import type { CliCommandOptions } from "../../types";
+export default function Down({ migrationTable, migrationPath, ...config }: CliCommandOptions): Promise<void>;

package/lib/src/migrations/commands/down.js

@@ -0,0 +1,74 @@
+"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.default = Down;
+const promises_1 = __importDefault(require("fs/promises"));
+const client_1 = require("../../client");
+const util_1 = require("../util");
+async function Down({ migrationTable, migrationPath, ...config }) {
+    const db = (0, client_1.createClient)(config);
+    await (0, util_1.validateMigrationDirectory)(migrationPath);
+    (0, util_1.createMigrationTableIfNotExists)(db, migrationTable);
+    // Query the last migration that was ran
+    const result = db.readOne("SELECT id, filepath FROM " + migrationTable + " ORDER BY timestamp DESC LIMIT 1");
+    if (!result) {
+        (0, util_1.logError)("No migrations have been ran");
+        process.exit(0);
+    }
+    const id = String(result["id"]);
+    const filepath = String(result["filepath"]);
+    const files = await promises_1.default.readdir(migrationPath);
+    const matchingFile = files.filter((file) => {
+        const fileName = file.split(".")[0];
+        return fileName === filepath;
+    });
+    if (!matchingFile.length) {
+        (0, util_1.logError)(`Unable to find migration ${filepath}`);
+        process.exit(0);
+    }
+    const migration = (await Promise.resolve(`${`${migrationPath}/${matchingFile[0]}`}`).then(s => __importStar(require(s)))).default;
+    // Run the migration
+    db.transaction(() => migration.down(db));
+    // Store the migration data
+    db.write({
+        sql: "DELETE FROM " + migrationTable + " WHERE id = :id",
+        args: { id },
+    });
+    (0, util_1.logSuccess)(`Reverted migration ${filepath}`);
+    process.exit(0);
+}

package/lib/src/migrations/commands/new.d.ts

@@ -0,0 +1,6 @@
+import { CliCommandOptions } from "../../types";
+interface NewCommandOptions extends CliCommandOptions {
+    name: string;
+}
+export default function New({ name, migrationPath }: NewCommandOptions): Promise<void>;
+export {};

package/lib/src/migrations/commands/new.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = New;
+const promises_1 = require("fs/promises");
+const util_1 = require("../util");
+async function New({ name, migrationPath }) {
+    const epochTime = Date.now();
+    const fileName = `${epochTime}_${name}.ts`;
+    const fileContents = `
+import type { NeosqliteClient } from 'neosqlite';
+
+export default class Migration_${epochTime}_${name} {
+  public static async up(db: NeosqliteClient) {
+    // Add your migration logic here
+  }
+
+  public static async down(db: NeosqliteClient) {
+    // Add your rollback logic here
+  }
+}
+  `;
+    await (0, promises_1.mkdir)(migrationPath, { recursive: true }).catch((e) => (0, util_1.logError)(e.message));
+    await (0, promises_1.writeFile)(`${migrationPath}/${fileName}`, fileContents).catch((e) => (0, util_1.logError)(e.message));
+    (0, util_1.logSuccess)(`Created migration ${fileName}`);
+    process.exit(0);
+}

package/lib/src/migrations/commands/up.d.ts

@@ -0,0 +1,2 @@
+import { CliCommandOptions } from "../../types";
+export default function Up({ migrationPath, migrationTable, ...config }: CliCommandOptions): Promise<void>;

package/lib/src/migrations/commands/up.js

@@ -0,0 +1,80 @@
+"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.default = Up;
+const promises_1 = __importDefault(require("fs/promises"));
+const client_1 = require("../../client");
+const util_1 = require("../util");
+async function Up({ migrationPath, migrationTable, ...config }) {
+    const db = (0, client_1.createClient)(config);
+    await (0, util_1.validateMigrationDirectory)(migrationPath);
+    (0, util_1.createMigrationTableIfNotExists)(db, migrationTable);
+    // Query all of the migrations that have already been ran
+    const result = db.read("SELECT filepath FROM " + migrationTable);
+    const migratedFiles = result.map((row) => String(row["filepath"]));
+    const files = await promises_1.default.readdir(migrationPath);
+    const migrationFiles = files.filter((file) => {
+        const fileName = file.split(".")[0];
+        return (file.endsWith(".ts") || file.endsWith(".js")) && !migratedFiles.includes(fileName);
+    });
+    if (!migrationFiles.length) {
+        (0, util_1.logWarn)("No migrations to run");
+        process.exit(0);
+    }
+    // Sort the files by timestamp, in ascending order so that they run in the order they were created
+    migrationFiles.sort((a, b) => {
+        const aTimestamp = parseInt(a.split("_")[0]);
+        const bTimestamp = parseInt(b.split("_")[0]);
+        return aTimestamp - bTimestamp;
+    });
+    // Apply the migrations
+    for (const fileName of migrationFiles) {
+        const migration = (await Promise.resolve(`${`${migrationPath}/${fileName}`}`).then(s => __importStar(require(s)))).default;
+        const normalizedFileName = fileName.split(".")[0];
+        // Run the migration
+        db.transaction(() => migration.up(db));
+        // Store the migration data
+        db.write({
+            sql: "INSERT INTO " + migrationTable + "(filepath, timestamp) VALUES (:filepath, :timestamp)",
+            args: { filepath: normalizedFileName, timestamp: Date.now() },
+        });
+        (0, util_1.logSuccess)(`Applied migration ${fileName}`);
+    }
+    (0, util_1.logSuccess)(`Successfully ran ${migrationFiles.length} migration(s)`);
+    process.exit(0);
+}

package/lib/src/migrations/index.d.ts

@@ -0,0 +1,6 @@
+import { CliCommandOptions, NeosqliteClient } from "../types";
+export interface MigrationFile {
+    up: (db: NeosqliteClient) => void;
+    down: (db: NeosqliteClient) => void;
+}
+export declare function createNeosqliteMigrationCli(props: CliCommandOptions): void;

package/lib/src/migrations/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNeosqliteMigrationCli = createNeosqliteMigrationCli;
+const commander_1 = require("commander");
+const up_1 = __importDefault(require("./commands/up"));
+const new_1 = __importDefault(require("./commands/new"));
+const down_1 = __importDefault(require("./commands/down"));
+const package_json_1 = __importDefault(require("../../package.json"));
+function createNeosqliteMigrationCli(props) {
+    props.migrationTable = props.migrationTable ?? "migrations";
+    const program = new commander_1.Command();
+    program.name("migrate").description("Migration CLI").version(package_json_1.default.version);
+    program
+        .command("up")
+        .description("Apply all unapplied migrations")
+        .action(() => (0, up_1.default)(props));
+    program
+        .command("down")
+        .description("Undo the last migration")
+        .action(() => (0, down_1.default)(props));
+    program
+        .command("new")
+        .option("-n, --name <name>", "The name of the migration")
+        .action((options) => {
+        if (!options.name) {
+            console.error("Please provide a name for the migration. Use the --name flag");
+            process.exit(1);
+        }
+        (0, new_1.default)({ ...props, name: options.name });
+    });
+    program.parse(process.argv);
+}

package/lib/src/migrations/util.d.ts

@@ -0,0 +1,9 @@
+import { NeosqliteClient } from "../types";
+export declare const logSuccess: (message: string) => void;
+export declare const logError: (message: string) => void;
+export declare const logWarn: (message: string) => void;
+export declare const createMigrationTableIfNotExists: (db: NeosqliteClient, migrationTable?: string) => {
+    changes: number;
+    lastInsertedRowid: number;
+};
+export declare const validateMigrationDirectory: (migrationPath: string) => Promise<void>;

package/lib/src/migrations/util.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMigrationDirectory = exports.createMigrationTableIfNotExists = exports.logWarn = exports.logError = exports.logSuccess = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const util_1 = require("../client/util");
+const RESET = "\x1b[0m";
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CHECK = "✔";
+const CROSS = "✖";
+const WARN = "⚠";
+const logSuccess = (message) => {
+    console.log(`${GREEN}${CHECK}${RESET} ${message}`);
+};
+exports.logSuccess = logSuccess;
+const logError = (message) => {
+    console.log(`${RED}${CROSS}${RESET} ${message}`);
+};
+exports.logError = logError;
+const logWarn = (message) => {
+    console.log(`${YELLOW}${WARN}${RESET} ${message}`);
+};
+exports.logWarn = logWarn;
+const createMigrationTableIfNotExists = (db, migrationTable = "migrations") => {
+    return db.write({
+        sql: (0, util_1.queryString)("CREATE TABLE IF NOT EXISTS " + migrationTable + "(", "  id INTEGER PRIMARY KEY AUTOINCREMENT,", "  filepath TEXT,", "  timestamp INTEGER", ")"),
+    });
+};
+exports.createMigrationTableIfNotExists = createMigrationTableIfNotExists;
+const validateMigrationDirectory = async (migrationPath) => {
+    try {
+        await promises_1.default.access(migrationPath);
+    }
+    catch (e) {
+        (0, exports.logError)("Unable to find the migration directory. Make sure it exists");
+        process.exit(0);
+    }
+};
+exports.validateMigrationDirectory = validateMigrationDirectory;

package/lib/src/types.d.ts

@@ -0,0 +1,75 @@
+import type { BackupMetadata, BackupOptions, PragmaOptions } from "better-sqlite3";
+export type NeosqliteConfig = {
+    /** The filename of the database */
+    file: ":memory:" | string;
+    /** When a query is logged using `logQuery: true`, you will receive the full query string via this callback */
+    onQueryLog?: (query: string) => void;
+    /** When a query finishes, gather data about the query from this callback */
+    onQueryComplete?: (data: OnQueryFinishData) => void;
+};
+export type NeosqliteClient = {
+    /** Call a pragma */
+    pragma: (source: string, options?: PragmaOptions | undefined) => unknown;
+    /** Backup the database */
+    backup: (destinationFile: string, options?: BackupOptions | undefined) => Promise<BackupMetadata>;
+    /** Create a transaction and execute queries within it */
+    transaction: (fn: Function) => void;
+    /** Read data from the database, returns all matching rows */
+    read: (params: ExecuteQueryParams) => Row[];
+    /** Read data from the database, returns the first matching row */
+    readOne: (params: ExecuteQueryParams) => Row | undefined;
+    /** Write data to the database, returns all matching rows via RETURNING */
+    writeReturning: (params: ExecuteQueryParams) => Row[];
+    /** Write data to the database, returns the number of rows affected */
+    write: (params: ExecuteQueryParams) => {
+        changes: number;
+        lastInsertedRowid: number;
+    };
+};
+export type OnQueryFinishData = {
+    /** The query that was executed */
+    query: string;
+    /** The time it took to execute the query in milliseconds */
+    time: number;
+};
+export type QueryParams = {
+    /** The SQL query to execute */
+    sql: string;
+    /** When true, the query string will be sent to onQueryLog */
+    logQuery?: boolean;
+    /** The values to bind to the query string */
+    args?: Record<string, number | string | boolean | null>;
+};
+export type Row = Record<string, number | string | boolean | null>;
+export type ExecuteQueryParams = string | QueryParams;
+export declare enum JobPriority {
+    Low = 1,
+    Medium = 2,
+    High = 3
+}
+export declare enum JobStatus {
+    Pending = "pending",
+    Running = "running",
+    Failed = "failed",
+    Completed = "completed"
+}
+export interface CliCommandOptions extends NeosqliteConfig {
+    /** The path containing the migration files */
+    migrationPath: string;
+    /** The name of the table to store migrations in. Defaults to "migrations" */
+    migrationTable?: string;
+}
+export interface CreateJobsOptions extends NeosqliteConfig {
+    /** The name of the table to store jobs in. Defaults to "jobs" */
+    jobsTable?: string;
+    /** How often to process jobs in milliseconds. Defaults to 5000 */
+    processEvery?: number;
+    /** The maximum number of retries for each job. Defaults to 3 */
+    maxRetries?: number;
+    /** The maximum number of jobs to execute at once. Defaults to 10 */
+    maxJobs?: number;
+}
+export interface JobOptions {
+    /** The priority of the job */
+    priority?: number;
+}

package/lib/src/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobStatus = exports.JobPriority = void 0;
+var JobPriority;
+(function (JobPriority) {
+    JobPriority[JobPriority["Low"] = 1] = "Low";
+    JobPriority[JobPriority["Medium"] = 2] = "Medium";
+    JobPriority[JobPriority["High"] = 3] = "High";
+})(JobPriority || (exports.JobPriority = JobPriority = {}));
+var JobStatus;
+(function (JobStatus) {
+    JobStatus["Pending"] = "pending";
+    JobStatus["Running"] = "running";
+    JobStatus["Failed"] = "failed";
+    JobStatus["Completed"] = "completed";
+})(JobStatus || (exports.JobStatus = JobStatus = {}));

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "neosqlite",
+  "description": "A lightweight wrapper around better-sqlite3 that adds developer-friendly features like job scheduling, migrations, error handling, query logging, SQL utilities, and more",
+  "version": "1.0.0",
+  "main": "lib/src/index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "sqlite",
+    "database",
+    "neosqlite"
+  ],
+  "author": "JS00001",
+  "license": "ISC",
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "chrono-node": "^2.8.4",
+    "commander": "^14.0.1",
+    "cron-parser": "^5.4.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}