@appweaver/core 1.0.0

package/memory/in-memory.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemory = void 0;
+const promises_1 = require("node:timers/promises");
+const flatted_1 = require("flatted");
+const common_1 = require("@appweaver/common");
+class InMemory extends common_1.Memory {
+    /** @internal */
+    _storage = new Map();
+    /** @internal */
+    _locks = new Map();
+    /** @internal */
+    _maxSizeBytes = (0, common_1.textToBytes)(common_1.config.MEMORY_MAX_SIZE);
+    /** @internal */
+    _approximatedSize = 0;
+    async onInit() {
+        await this.connect();
+    }
+    async onDestroy() {
+        await this.disconnect();
+    }
+    async connect() {
+        // no-op
+    }
+    async disconnect() {
+        // no-op
+    }
+    createClient() {
+        // no-op
+    }
+    async getValue(key) {
+        const entry = this._storage.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check if expired
+        if (entry.expiresAt && entry.expiresAt < Date.now()) {
+            await this.cleanupExpired();
+            return null;
+        }
+        return (0, flatted_1.parse)(entry.value);
+    }
+    async putValue(key, value, expireMs) {
+        await this.cleanupExpired();
+        const jsonValue = (0, flatted_1.stringify)(value);
+        const expiresAt = expireMs ? Date.now() + expireMs : undefined;
+        this._storage.set(key, {
+            value: jsonValue,
+            expiresAt
+        });
+        this._approximatedSize += Buffer.byteLength(jsonValue, 'utf8');
+        // If memory max size is reached, remove entries from start until the size
+        // is below the configured value
+        if (this._maxSizeBytes) {
+            while (this._approximatedSize > this._maxSizeBytes) {
+                await this.removeValue(this._storage.keys()[0]);
+            }
+        }
+        return true;
+    }
+    async hasKey(key) {
+        return this._storage.has(key);
+    }
+    async removeValue(key) {
+        const jsonValue = await this.getValue(key);
+        if (!jsonValue) {
+            return false;
+        }
+        const deleted = this._storage.delete(key);
+        this._approximatedSize -= Buffer.byteLength(jsonValue, 'utf8');
+        if (this._approximatedSize < 0) {
+            this._approximatedSize = 0;
+        }
+        return deleted;
+    }
+    async removeEntries(query) {
+        const keys = await this.findKeys(query);
+        const removeActions = Array.from(keys).map((key) => this.removeValue(key));
+        const results = await Promise.allSettled(removeActions);
+        return results.filter((r) => r.status === 'fulfilled' && r.value).length;
+    }
+    async findKeys(pattern = '*') {
+        const matchingKeys = new Set();
+        // Convert glob pattern to regex
+        const regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`);
+        for (const key of this._storage.keys()) {
+            const entry = this._storage.get(key);
+            if (entry && entry.expiresAt && entry.expiresAt < Date.now()) {
+                this._storage.delete(key);
+                continue;
+            }
+            if (regex.test(key)) {
+                matchingKeys.add(key);
+            }
+        }
+        return matchingKeys;
+    }
+    async valueSizeBytes(key) {
+        const entry = this._storage.get(key);
+        return entry ? Buffer.byteLength(entry.value, 'utf8') : null;
+    }
+    async lock(resource, lockConfig = {}) {
+        const expireMs = lockConfig.expireMs ?? 5000;
+        const retryCount = lockConfig.retryCount ?? 10;
+        const retryDelay = lockConfig.retryDelay ?? 200;
+        const resourceKey = `lock:${resource}`;
+        const lockValue = (0, common_1.uuid)();
+        let retries = 0;
+        do {
+            // Try to acquire lock (NX semantics - only set if not exists)
+            const existingLock = this._locks.get(resourceKey);
+            // Check if the existing lock is expired
+            if (existingLock && existingLock.expiresAt < Date.now()) {
+                this._locks.delete(resourceKey);
+            }
+            // Try to acquire
+            if (!this._locks.has(resourceKey)) {
+                this._locks.set(resourceKey, {
+                    value: lockValue,
+                    expiresAt: Date.now() + expireMs
+                });
+                return {
+                    release: async () => {
+                        // Only release if the lock value matches
+                        const currentLock = this._locks.get(resourceKey);
+                        if (currentLock && currentLock.value === lockValue) {
+                            this._locks.delete(resourceKey);
+                            return true;
+                        }
+                        return false;
+                    }
+                };
+            }
+            await (0, promises_1.setTimeout)(retryDelay);
+            retries++;
+        } while (retries < retryCount);
+        throw new Error('Unable to acquire lock on requested resource');
+    }
+    async checkHealth() {
+        return { success: true };
+    }
+    async cleanupExpired() {
+        const now = Date.now();
+        // Clean up expired storage entries
+        for (const key in this._storage.keys()) {
+            const entry = this._storage.get(key);
+            if (entry && entry.expiresAt && entry.expiresAt < now) {
+                await this.removeValue(key);
+            }
+        }
+        // Clean up expired locks
+        for (const key in this._locks.keys()) {
+            const lock = this._locks.get(key);
+            if (lock && lock.expiresAt < now) {
+                this._locks.delete(key);
+            }
+        }
+    }
+}
+exports.InMemory = InMemory;

package/memory/redis.d.ts

@@ -0,0 +1,26 @@
+import { Redis as RedisClient, RedisOptions } from 'ioredis';
+import { HealthCheckResult, Redis as CommonRedis } from '@appweaver/common';
+export declare class Redis extends CommonRedis<RedisOptions, RedisClient> {
+    constructor();
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+    createClient(options?: RedisOptions): RedisClient;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getValue<T = any>(key: string): Promise<T | null>;
+    putValue(key: string, value: any, expireMs?: number): Promise<boolean>;
+    hasKey(key: string): Promise<boolean>;
+    removeValue(key: string): Promise<boolean>;
+    removeEntries(query: string): Promise<number>;
+    findKeys(pattern?: string): Promise<Set<string>>;
+    valueSizeBytes(key: string): Promise<number | null>;
+    lock(resource: string, lockConfig?: {
+        expireMs?: number;
+        retryCount?: number;
+        retryDelay?: number;
+    }): Promise<{
+        release: () => Promise<boolean>;
+    }>;
+    checkHealth(): Promise<HealthCheckResult>;
+    private parseConnectionUrl;
+}

package/memory/redis.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Redis = void 0;
+const promises_1 = require("node:timers/promises");
+const ioredis_1 = require("ioredis");
+const flatted_1 = require("flatted");
+const common_1 = require("@appweaver/common");
+class Redis extends common_1.Redis {
+    /** @internal */
+    _options;
+    /** @internal */
+    _client;
+    constructor() {
+        super();
+        this._options = this.parseConnectionUrl(common_1.config.REDIS_URL);
+        this._client = this.createClient({ lazyConnect: true });
+    }
+    async onInit() {
+        await this.connect();
+    }
+    async onDestroy() {
+        await this.disconnect();
+    }
+    createClient(options = {}) {
+        return new ioredis_1.Redis({
+            ...this._options,
+            ...options
+        });
+    }
+    async connect() {
+        await this._client.connect();
+    }
+    async disconnect() {
+        try {
+            await this._client.quit();
+        }
+        catch {
+            // Ignore already closed connection error
+        }
+    }
+    async getValue(key) {
+        const value = await this._client.get(key);
+        return value ? (0, flatted_1.parse)(value) : null;
+    }
+    async putValue(key, value, expireMs) {
+        const jsonValue = (0, flatted_1.stringify)(value);
+        const result = expireMs
+            ? await this._client.set(key, jsonValue, 'PX', expireMs)
+            : await this._client.set(key, jsonValue);
+        return result === 'OK';
+    }
+    async hasKey(key) {
+        const result = await this._client.exists(key);
+        return result === 1;
+    }
+    async removeValue(key) {
+        const result = await this._client.del(key);
+        return result > 0;
+    }
+    async removeEntries(query) {
+        const keys = await this.findKeys(query);
+        if (keys.size === 0) {
+            return 0;
+        }
+        return this._client.del(...keys);
+    }
+    async findKeys(pattern = '*') {
+        return new Promise((resolve) => {
+            const stream = this._client.scanStream({
+                match: pattern,
+                count: 10000
+            });
+            const keysSet = new Set();
+            stream.on('data', (keys) => {
+                stream.pause();
+                keys.forEach((key) => keysSet.add(key));
+                stream.resume();
+            });
+            stream.on('end', () => {
+                resolve(keysSet);
+            });
+        });
+    }
+    async valueSizeBytes(key) {
+        return this._client.memory('USAGE', key);
+    }
+    async lock(resource, lockConfig = {}) {
+        const redisLock = new RedisLock(this._client, resource, lockConfig.expireMs, lockConfig.retryCount, lockConfig.retryDelay);
+        return await redisLock.lock();
+    }
+    async checkHealth() {
+        try {
+            const result = await this._client.ping();
+            return { success: result === 'PONG' };
+        }
+        catch (e) {
+            return { success: false, message: e.message };
+        }
+    }
+    parseConnectionUrl(url) {
+        const urlPattern = /redis:\/\/(?:(.*?)(?::(.*?))?@)?(.*?):(\d+)(?:\/(\d+))?/;
+        const match = url.match(urlPattern);
+        if (!match) {
+            return { host: 'localhost', port: 6379 };
+        }
+        const username = match[2] ? match[1] : undefined;
+        const password = match[2] || match[1];
+        const host = match[3] || 'localhost';
+        const port = parseInt(match[4], 10) || 6379;
+        const db = match[5] ? parseInt(match[5], 10) : undefined;
+        return { username, password, host, port, db };
+    }
+}
+exports.Redis = Redis;
+class RedisLock {
+    client;
+    resource;
+    expireMs;
+    retryCount;
+    retryDelay;
+    /** @internal */
+    _releaseLockCommand = 'releaseLock';
+    constructor(client, resource, expireMs = 5000, retryCount = 10, retryDelay = 200) {
+        this.client = client;
+        this.resource = resource;
+        this.expireMs = expireMs;
+        this.retryCount = retryCount;
+        this.retryDelay = retryDelay;
+        this.initReleaseLockScript();
+    }
+    async lock() {
+        const resourceKey = `lock:${this.resource}`;
+        const lockValue = (0, common_1.uuid)();
+        let retries = 0;
+        do {
+            const result = await this.client.set(resourceKey, lockValue, 'PX', this.expireMs, 'NX');
+            if (result === 'OK') {
+                return {
+                    release: async () => (await this.client[this._releaseLockCommand](resourceKey, lockValue)) > 0
+                };
+            }
+            else {
+                await (0, promises_1.setTimeout)(this.retryDelay);
+                retries++;
+            }
+        } while (retries < this.retryCount);
+        throw new Error('Unable to acquire lock on requested resource');
+    }
+    initReleaseLockScript() {
+        if (this._releaseLockCommand in this.client) {
+            return;
+        }
+        this.client.defineCommand(this._releaseLockCommand, {
+            numberOfKeys: 1,
+            lua: 'if redis.call("get",KEYS[1]) == ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end'
+        });
+    }
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@appweaver/core",
+  "version": "1.0.0",
+  "description": "Appweaver - simple, fast, and reliable web application builder tool (@core)",
+  "author": "Luka Matosevic",
+  "license": "UNLICENSED",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lmatosevic/appweaver.git",
+    "directory": "packages/core"
+  },
+  "maintainers": [
+    {
+      "name": "Luka Matosevic",
+      "email": "lukamatosevic5@gmail.com",
+      "web": "https://lukamatosevic.com"
+    }
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "scripts": {
+    "generate": "weaver generate --modelPattern ./**/model.ts --typesPath ./types/generated.ts --schemaPath ./prisma/schema.prisma --clientPath ./prisma/client",
+    "db:recreate": "rimraf dev.db && rimraf prisma/migrations --glob \"*_init\" && weaver migration new init"
+  },
+  "dependencies": {
+    "@fastify/auth": "5.0.4",
+    "@fastify/basic-auth": "6.2.0",
+    "@fastify/cors": "11.2.0",
+    "@fastify/helmet": "13.0.2",
+    "@fastify/jwt": "10.0.0",
+    "@fastify/multipart": "9.4.0",
+    "@fastify/oauth2": "8.2.0",
+    "@fastify/rate-limit": "10.3.0",
+    "@fastify/request-context": "6.2.1",
+    "@fastify/static": "9.1.3",
+    "@fastify/swagger": "9.6.1",
+    "@fastify/swagger-ui": "5.2.4",
+    "@fastify/type-provider-typebox": "6.1.0",
+    "@sinclair/typebox": "0.34.47",
+    "bcrypt": "6.0.0",
+    "csv-stringify": "6.6.0",
+    "date-fns": "4.1.0",
+    "fastify": "5.8.5",
+    "fastify-plugin": "5.1.0",
+    "flatted": "3.4.2"
+  },
+  "devDependencies": {
+    "@appweaver/common": "^1.0.0",
+    "@prisma/adapter-better-sqlite3": "^7.3.0",
+    "@prisma/client": "^7.3.0",
+    "bullmq": "^5.70.0",
+    "cron": "^4.4.0",
+    "ioredis": "^5.9.0",
+    "nodemailer": "^8.0.0",
+    "prisma": "^7.3.0",
+    "rimraf": "6.1.2"
+  },
+  "peerDependencies": {
+    "@appweaver/common": "^1.0.0",
+    "@prisma/client": "^7.3.0"
+  }
+}

package/prisma/client/browser.d.ts

@@ -0,0 +1,34 @@
+import * as Prisma from './internal/prismaNamespaceBrowser';
+export { Prisma };
+export * as $Enums from './enums';
+export * from './enums';
+/**
+ * Model ApiKey
+ *
+ */
+export type ApiKey = Prisma.ApiKeyModel;
+/**
+ * Model OneTimeToken
+ *
+ */
+export type OneTimeToken = Prisma.OneTimeTokenModel;
+/**
+ * Model Permission
+ *
+ */
+export type Permission = Prisma.PermissionModel;
+/**
+ * Model Role
+ *
+ */
+export type Role = Prisma.RoleModel;
+/**
+ * Model Seeder
+ *
+ */
+export type Seeder = Prisma.SeederModel;
+/**
+ * Model File
+ *
+ */
+export type File = Prisma.FileModel;

package/prisma/client/browser.js

@@ -0,0 +1,56 @@
+"use strict";
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma-related types and utilities in a browser.
+ * Use it to get access to models, enums, and input types.
+ *
+ * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only.
+ * See `client.ts` for the standard, server-side entry point.
+ *
+ * 🟢 You can import this file directly.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Enums = exports.Prisma = void 0;
+const Prisma = __importStar(require("./internal/prismaNamespaceBrowser"));
+exports.Prisma = Prisma;
+exports.$Enums = __importStar(require("./enums"));
+__exportStar(require("./enums"), exports);

package/prisma/client/client.d.ts

@@ -0,0 +1,53 @@
+import * as runtime from "@prisma/client/runtime/client";
+import * as $Class from "./internal/class";
+import * as Prisma from "./internal/prismaNamespace";
+export * as $Enums from './enums';
+export * from "./enums";
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more ApiKeys
+ * const apiKeys = await prisma.apiKey.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export declare const PrismaClient: $Class.PrismaClientConstructor;
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+export { Prisma };
+/**
+ * Model ApiKey
+ *
+ */
+export type ApiKey = Prisma.ApiKeyModel;
+/**
+ * Model OneTimeToken
+ *
+ */
+export type OneTimeToken = Prisma.OneTimeTokenModel;
+/**
+ * Model Permission
+ *
+ */
+export type Permission = Prisma.PermissionModel;
+/**
+ * Model Role
+ *
+ */
+export type Role = Prisma.RoleModel;
+/**
+ * Model Seeder
+ *
+ */
+export type Seeder = Prisma.SeederModel;
+/**
+ * Model File
+ *
+ */
+export type File = Prisma.FileModel;

package/prisma/client/client.js

@@ -0,0 +1,70 @@
+"use strict";
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
+ * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead.
+ *
+ * 🟢 You can import this file directly.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Prisma = exports.PrismaClient = exports.$Enums = void 0;
+const $Class = __importStar(require("./internal/class"));
+const Prisma = __importStar(require("./internal/prismaNamespace"));
+exports.Prisma = Prisma;
+exports.$Enums = __importStar(require("./enums"));
+__exportStar(require("./enums"), exports);
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more ApiKeys
+ * const apiKeys = await prisma.apiKey.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+exports.PrismaClient = $Class.getPrismaClientClass();