@carno.js/core 0.2.11 → 1.0.2

package/dist/cache/CacheDriver.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var CacheDriver_exports = {};
+module.exports = __toCommonJS(CacheDriver_exports);

package/dist/cache/CacheService.js

@@ -0,0 +1,113 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var CacheService_exports = {};
+__export(CacheService_exports, {
+  CacheService: () => CacheService
+});
+module.exports = __toCommonJS(CacheService_exports);
+var import_MemoryDriver = require('./MemoryDriver.js');
+class CacheService {
+  constructor(config = {}) {
+    this.driver = config.driver || new import_MemoryDriver.MemoryDriver(), this.prefix = config.prefix || "", this.defaultTtl = config.defaultTtl;
+  }
+  /**
+   * Get the full key with prefix.
+   */
+  key(key) {
+    return this.prefix ? `${this.prefix}:${key}` : key;
+  }
+  /**
+   * Get a value from cache.
+   */
+  async get(key) {
+    return this.driver.get(this.key(key));
+  }
+  /**
+   * Set a value in cache.
+   * @param ttl Time to live in seconds
+   */
+  async set(key, value, ttl) {
+    return this.driver.set(this.key(key), value, ttl ?? this.defaultTtl);
+  }
+  /**
+   * Delete a value from cache.
+   */
+  async del(key) {
+    return this.driver.del(this.key(key));
+  }
+  /**
+   * Check if key exists.
+   */
+  async has(key) {
+    return this.driver.has(this.key(key));
+  }
+  /**
+   * Clear all cached values.
+   */
+  async clear() {
+    return this.driver.clear();
+  }
+  /**
+   * Get value from cache or compute and store it.
+   * This is the cache-aside pattern - most commonly used method.
+   * 
+   * @param key Cache key
+   * @param cb Callback to compute value if not cached
+   * @param ttl Time to live in seconds
+   */
+  async getOrSet(key, cb, ttl) {
+    const cached = await this.get(key);
+    if (cached !== null)
+      return cached;
+    const value = await cb();
+    return await this.set(key, value, ttl), value;
+  }
+  /**
+   * Get multiple values at once.
+   */
+  async getMany(keys) {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+  /**
+   * Set multiple values at once.
+   */
+  async setMany(entries) {
+    return Promise.all(
+      entries.map((entry) => this.set(entry.key, entry.value, entry.ttl))
+    );
+  }
+  /**
+   * Delete multiple values at once.
+   */
+  async delMany(keys) {
+    return Promise.all(keys.map((key) => this.del(key)));
+  }
+  /**
+   * Close the cache driver connection.
+   */
+  async close() {
+    await this.driver.close?.();
+  }
+  /**
+   * Get the underlying driver (for advanced use).
+   */
+  getDriver() {
+    return this.driver;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheService
+});

package/dist/cache/CacheService.mjs

@@ -0,0 +1,93 @@
+import { MemoryDriver } from "./MemoryDriver.mjs";
+class CacheService {
+  constructor(config = {}) {
+    this.driver = config.driver || new MemoryDriver(), this.prefix = config.prefix || "", this.defaultTtl = config.defaultTtl;
+  }
+  /**
+   * Get the full key with prefix.
+   */
+  key(key) {
+    return this.prefix ? `${this.prefix}:${key}` : key;
+  }
+  /**
+   * Get a value from cache.
+   */
+  async get(key) {
+    return this.driver.get(this.key(key));
+  }
+  /**
+   * Set a value in cache.
+   * @param ttl Time to live in seconds
+   */
+  async set(key, value, ttl) {
+    return this.driver.set(this.key(key), value, ttl ?? this.defaultTtl);
+  }
+  /**
+   * Delete a value from cache.
+   */
+  async del(key) {
+    return this.driver.del(this.key(key));
+  }
+  /**
+   * Check if key exists.
+   */
+  async has(key) {
+    return this.driver.has(this.key(key));
+  }
+  /**
+   * Clear all cached values.
+   */
+  async clear() {
+    return this.driver.clear();
+  }
+  /**
+   * Get value from cache or compute and store it.
+   * This is the cache-aside pattern - most commonly used method.
+   * 
+   * @param key Cache key
+   * @param cb Callback to compute value if not cached
+   * @param ttl Time to live in seconds
+   */
+  async getOrSet(key, cb, ttl) {
+    const cached = await this.get(key);
+    if (cached !== null)
+      return cached;
+    const value = await cb();
+    return await this.set(key, value, ttl), value;
+  }
+  /**
+   * Get multiple values at once.
+   */
+  async getMany(keys) {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+  /**
+   * Set multiple values at once.
+   */
+  async setMany(entries) {
+    return Promise.all(
+      entries.map((entry) => this.set(entry.key, entry.value, entry.ttl))
+    );
+  }
+  /**
+   * Delete multiple values at once.
+   */
+  async delMany(keys) {
+    return Promise.all(keys.map((key) => this.del(key)));
+  }
+  /**
+   * Close the cache driver connection.
+   */
+  async close() {
+    await this.driver.close?.();
+  }
+  /**
+   * Get the underlying driver (for advanced use).
+   */
+  getDriver() {
+    return this.driver;
+  }
+}
+export {
+  CacheService
+};

package/dist/cache/MemoryDriver.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var MemoryDriver_exports = {};
+__export(MemoryDriver_exports, {
+  MemoryDriver: () => MemoryDriver
+});
+module.exports = __toCommonJS(MemoryDriver_exports);
+class MemoryDriver {
+  constructor(cleanupIntervalMs = 0) {
+    this.name = "MemoryDriver";
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupInterval = null;
+    cleanupIntervalMs > 0 && (this.cleanupInterval = setInterval(() => this.cleanup(), cleanupIntervalMs));
+  }
+  async get(key) {
+    const entry = this.cache.get(key);
+    return entry ? entry.expiresAt !== null && Date.now() > entry.expiresAt ? (this.cache.delete(key), null) : entry.value : null;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = ttl ? Date.now() + ttl : null;
+    return this.cache.set(key, { value, expiresAt }), !0;
+  }
+  async del(key) {
+    return this.cache.delete(key);
+  }
+  async has(key) {
+    const entry = this.cache.get(key);
+    return entry ? entry.expiresAt !== null && Date.now() > entry.expiresAt ? (this.cache.delete(key), !1) : !0 : !1;
+  }
+  async clear() {
+    this.cache.clear();
+  }
+  async close() {
+    this.cleanupInterval && (clearInterval(this.cleanupInterval), this.cleanupInterval = null), this.cache.clear();
+  }
+  /**
+   * Remove expired entries.
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache)
+      entry.expiresAt !== null && now > entry.expiresAt && this.cache.delete(key);
+  }
+  /**
+   * Get cache stats (for debugging).
+   */
+  stats() {
+    return { size: this.cache.size };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryDriver
+});

package/dist/cache/MemoryDriver.mjs

@@ -0,0 +1,46 @@
+class MemoryDriver {
+  constructor(cleanupIntervalMs = 0) {
+    this.name = "MemoryDriver";
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupInterval = null;
+    cleanupIntervalMs > 0 && (this.cleanupInterval = setInterval(() => this.cleanup(), cleanupIntervalMs));
+  }
+  async get(key) {
+    const entry = this.cache.get(key);
+    return entry ? entry.expiresAt !== null && Date.now() > entry.expiresAt ? (this.cache.delete(key), null) : entry.value : null;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = ttl ? Date.now() + ttl : null;
+    return this.cache.set(key, { value, expiresAt }), !0;
+  }
+  async del(key) {
+    return this.cache.delete(key);
+  }
+  async has(key) {
+    const entry = this.cache.get(key);
+    return entry ? entry.expiresAt !== null && Date.now() > entry.expiresAt ? (this.cache.delete(key), !1) : !0 : !1;
+  }
+  async clear() {
+    this.cache.clear();
+  }
+  async close() {
+    this.cleanupInterval && (clearInterval(this.cleanupInterval), this.cleanupInterval = null), this.cache.clear();
+  }
+  /**
+   * Remove expired entries.
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache)
+      entry.expiresAt !== null && now > entry.expiresAt && this.cache.delete(key);
+  }
+  /**
+   * Get cache stats (for debugging).
+   */
+  stats() {
+    return { size: this.cache.size };
+  }
+}
+export {
+  MemoryDriver
+};

package/dist/cache/RedisDriver.js

@@ -0,0 +1,81 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var RedisDriver_exports = {};
+__export(RedisDriver_exports, {
+  RedisDriver: () => RedisDriver
+});
+module.exports = __toCommonJS(RedisDriver_exports);
+class RedisDriver {
+  constructor(config = {}) {
+    this.config = config;
+    this.name = "RedisDriver";
+    this.client = null;
+    this.connected = !1;
+  }
+  /**
+   * Connect to Redis (lazy - connects on first use).
+   */
+  async ensureConnected() {
+    if (this.connected) return;
+    const url = this.config.url || `redis://${this.config.host || "localhost"}:${this.config.port || 6379}`;
+    if (typeof Bun < "u" && Bun.redis)
+      this.client = new Bun.redis(url);
+    else
+      try {
+        const Redis = require("ioredis");
+        this.client = new Redis({
+          host: this.config.host || "localhost",
+          port: this.config.port || 6379,
+          password: this.config.password,
+          db: this.config.db || 0
+        });
+      } catch {
+        throw new Error("Redis client not available. Install ioredis or use Bun with Redis support.");
+      }
+    this.connected = !0;
+  }
+  async get(key) {
+    await this.ensureConnected();
+    const value = await this.client.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async set(key, value, ttl) {
+    await this.ensureConnected();
+    const serialized = typeof value == "string" ? value : JSON.stringify(value);
+    return ttl ? await this.client.setex(key, ttl, serialized) : await this.client.set(key, serialized), !0;
+  }
+  async del(key) {
+    return await this.ensureConnected(), await this.client.del(key) > 0;
+  }
+  async has(key) {
+    return await this.ensureConnected(), await this.client.exists(key) > 0;
+  }
+  async clear() {
+    await this.ensureConnected(), await this.client.flushdb();
+  }
+  async close() {
+    this.client && this.connected && (await this.client.quit?.(), this.connected = !1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisDriver
+});

package/dist/cache/RedisDriver.mjs

@@ -0,0 +1,61 @@
+class RedisDriver {
+  constructor(config = {}) {
+    this.config = config;
+    this.name = "RedisDriver";
+    this.client = null;
+    this.connected = !1;
+  }
+  /**
+   * Connect to Redis (lazy - connects on first use).
+   */
+  async ensureConnected() {
+    if (this.connected) return;
+    const url = this.config.url || `redis://${this.config.host || "localhost"}:${this.config.port || 6379}`;
+    if (typeof Bun < "u" && Bun.redis)
+      this.client = new Bun.redis(url);
+    else
+      try {
+        const Redis = require("ioredis");
+        this.client = new Redis({
+          host: this.config.host || "localhost",
+          port: this.config.port || 6379,
+          password: this.config.password,
+          db: this.config.db || 0
+        });
+      } catch {
+        throw new Error("Redis client not available. Install ioredis or use Bun with Redis support.");
+      }
+    this.connected = !0;
+  }
+  async get(key) {
+    await this.ensureConnected();
+    const value = await this.client.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async set(key, value, ttl) {
+    await this.ensureConnected();
+    const serialized = typeof value == "string" ? value : JSON.stringify(value);
+    return ttl ? await this.client.setex(key, ttl, serialized) : await this.client.set(key, serialized), !0;
+  }
+  async del(key) {
+    return await this.ensureConnected(), await this.client.del(key) > 0;
+  }
+  async has(key) {
+    return await this.ensureConnected(), await this.client.exists(key) > 0;
+  }
+  async clear() {
+    await this.ensureConnected(), await this.client.flushdb();
+  }
+  async close() {
+    this.client && this.connected && (await this.client.quit?.(), this.connected = !1);
+  }
+}
+export {
+  RedisDriver
+};

package/dist/compiler/JITCompiler.js

@@ -0,0 +1,111 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var JITCompiler_exports = {};
+__export(JITCompiler_exports, {
+  compileHandler: () => compileHandler,
+  isAsyncFunction: () => isAsyncFunction,
+  isStaticHandler: () => isStaticHandler
+});
+module.exports = __toCommonJS(JITCompiler_exports);
+const ASYNC_REGEX = /^async\s|^\([^)]*\)\s*=>\s*\{[\s\S]*await\s|^function\s*\*|\.then\s*\(/;
+function isAsyncFunction(fn) {
+  if (fn.constructor.name === "AsyncFunction")
+    return !0;
+  const source = fn.toString();
+  return ASYNC_REGEX.test(source);
+}
+function isStaticHandler(fn) {
+  const source = fn.toString();
+  return source.includes("this.") || source.includes("await") ? !1 : !!source.match(/=>\s*["'`]|return\s+["'`]|=>\s*\{|=>\s*\d/);
+}
+function compileHandler(instance, methodName, params) {
+  const method = instance[methodName], bound = method.bind(instance), async = isAsyncFunction(method);
+  if (params.length === 0) {
+    if (isStaticHandler(method) && !async) {
+      const staticValue = bound();
+      return {
+        fn: bound,
+        isAsync: !1,
+        isStatic: !0,
+        staticValue
+      };
+    }
+    return {
+      fn: bound,
+      isAsync: async,
+      isStatic: !1
+    };
+  }
+  const argsCode = params.sort((a, b) => a.index - b.index).map((p) => buildArgExpression(p)).join(",");
+  if (params.some((p) => p.type === "body")) {
+    const code2 = `return async function(c){
+await c.parseBody();
+return h(${argsCode});
+}`;
+    return {
+      fn: new Function("h", code2)(bound),
+      isAsync: !0,
+      isStatic: !1
+    };
+  }
+  if (async) {
+    const code2 = `return async function(c){
+return await h(${argsCode});
+}`;
+    return {
+      fn: new Function("h", code2)(bound),
+      isAsync: !0,
+      isStatic: !1
+    };
+  }
+  const code = `return function(c){
+return h(${argsCode});
+}`;
+  return {
+    fn: new Function("h", code)(bound),
+    isAsync: !1,
+    isStatic: !1
+  };
+}
+function escapeKey(key) {
+  return key.replace(/['\"\\]/g, "\\$&");
+}
+function buildArgExpression(param) {
+  const key = param.key ? escapeKey(param.key) : void 0;
+  switch (param.type) {
+    case "param":
+      return key ? `c.params['${key}']` : "c.params";
+    case "query":
+      return key ? `c.query['${key}']` : "c.query";
+    case "body":
+      return key ? `c.body['${key}']` : "c.body";
+    case "header":
+      return key ? `c.req.headers.get('${key}')` : "c.req.headers";
+    case "req":
+      return "c.req";
+    case "ctx":
+      return "c";
+    case "locals":
+      return key ? `c.locals['${key}']` : "c.locals";
+    default:
+      return "undefined";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileHandler,
+  isAsyncFunction,
+  isStaticHandler
+});

package/dist/compiler/JITCompiler.mjs

@@ -0,0 +1,89 @@
+const ASYNC_REGEX = /^async\s|^\([^)]*\)\s*=>\s*\{[\s\S]*await\s|^function\s*\*|\.then\s*\(/;
+function isAsyncFunction(fn) {
+  if (fn.constructor.name === "AsyncFunction")
+    return !0;
+  const source = fn.toString();
+  return ASYNC_REGEX.test(source);
+}
+function isStaticHandler(fn) {
+  const source = fn.toString();
+  return source.includes("this.") || source.includes("await") ? !1 : !!source.match(/=>\s*["'`]|return\s+["'`]|=>\s*\{|=>\s*\d/);
+}
+function compileHandler(instance, methodName, params) {
+  const method = instance[methodName], bound = method.bind(instance), async = isAsyncFunction(method);
+  if (params.length === 0) {
+    if (isStaticHandler(method) && !async) {
+      const staticValue = bound();
+      return {
+        fn: bound,
+        isAsync: !1,
+        isStatic: !0,
+        staticValue
+      };
+    }
+    return {
+      fn: bound,
+      isAsync: async,
+      isStatic: !1
+    };
+  }
+  const argsCode = params.sort((a, b) => a.index - b.index).map((p) => buildArgExpression(p)).join(",");
+  if (params.some((p) => p.type === "body")) {
+    const code2 = `return async function(c){
+await c.parseBody();
+return h(${argsCode});
+}`;
+    return {
+      fn: new Function("h", code2)(bound),
+      isAsync: !0,
+      isStatic: !1
+    };
+  }
+  if (async) {
+    const code2 = `return async function(c){
+return await h(${argsCode});
+}`;
+    return {
+      fn: new Function("h", code2)(bound),
+      isAsync: !0,
+      isStatic: !1
+    };
+  }
+  const code = `return function(c){
+return h(${argsCode});
+}`;
+  return {
+    fn: new Function("h", code)(bound),
+    isAsync: !1,
+    isStatic: !1
+  };
+}
+function escapeKey(key) {
+  return key.replace(/['\"\\]/g, "\\$&");
+}
+function buildArgExpression(param) {
+  const key = param.key ? escapeKey(param.key) : void 0;
+  switch (param.type) {
+    case "param":
+      return key ? `c.params['${key}']` : "c.params";
+    case "query":
+      return key ? `c.query['${key}']` : "c.query";
+    case "body":
+      return key ? `c.body['${key}']` : "c.body";
+    case "header":
+      return key ? `c.req.headers.get('${key}')` : "c.req.headers";
+    case "req":
+      return "c.req";
+    case "ctx":
+      return "c";
+    case "locals":
+      return key ? `c.locals['${key}']` : "c.locals";
+    default:
+      return "undefined";
+  }
+}
+export {
+  compileHandler,
+  isAsyncFunction,
+  isStaticHandler
+};