@devbro/pashmak 0.1.16 → 0.1.17

package/dist/bin/app/console/DefaultCommand.cjs

@@ -560,6 +560,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -625,8 +626,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -711,6 +737,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/DefaultCommand.mts
 var DefaultCommand = class extends import_clipanion2.Command {

package/dist/bin/app/console/KeyGenerateCommand.cjs

@@ -563,6 +563,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -628,8 +629,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -714,6 +740,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/KeyGenerateCommand.mts
 var KeyGenerateCommand = class extends import_clipanion2.Command {

package/dist/bin/app/console/StartCommand.cjs

@@ -561,6 +561,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -626,8 +627,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -712,6 +738,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/StartCommand.mts
 var import_neko_sql2 = require("@devbro/neko-sql");

package/dist/bin/app/console/generate/GenerateControllerCommand.cjs

@@ -559,6 +559,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -624,8 +625,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -710,6 +736,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/generate/GenerateControllerCommand.mts
 var import_clipanion2 = require("clipanion");

package/dist/bin/app/console/generate/index.cjs

@@ -559,6 +559,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -624,8 +625,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -710,6 +736,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/generate/GenerateControllerCommand.mts
 var import_clipanion2 = require("clipanion");

package/dist/bin/app/console/index.cjs

@@ -1722,6 +1722,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -1787,8 +1788,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -1874,6 +1900,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/migrate/MigrateCommand.mts
 var import_clipanion2 = require("clipanion");

package/dist/bin/app/console/migrate/GenerateMigrateCommand.cjs

@@ -559,6 +559,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -624,8 +625,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -710,6 +736,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/migrate/GenerateMigrateCommand.mts
 var import_clipanion2 = require("clipanion");

package/dist/bin/app/console/migrate/MigrateCommand.cjs

@@ -559,6 +559,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -624,8 +625,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -711,6 +737,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/migrate/MigrateCommand.mts
 var import_clipanion2 = require("clipanion");

package/dist/bin/app/console/migrate/MigrateRollbackCommand.cjs

@@ -1714,6 +1714,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -1779,8 +1780,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -1866,6 +1892,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/migrate/MigrateRollbackCommand.mts
 var import_clipanion2 = require("clipanion");

package/dist/bin/app/console/migrate/index.cjs

@@ -1716,6 +1716,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -1781,8 +1782,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -1868,6 +1894,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/migrate/MigrateCommand.mts
 var import_clipanion2 = require("clipanion");

package/dist/bin/app/console/queue/GenerateQueueMigrateCommand.cjs

@@ -559,6 +559,7 @@ var DatabaseTransport = class {
 };
 
 // src/factories.mts
+var import_neko_cache = require("@devbro/neko-cache");
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -624,8 +625,33 @@ QueueFactory.register("memory", (opt) => {
   let transport = new import_neko_queue2.MemoryTransport(opt);
   return new import_neko_queue.QueueConnection(transport);
 });
+var CacheProviderFactory = class _CacheProviderFactory {
+  static {
+    __name(this, "CacheProviderFactory");
+  }
+  static instance = new FlexibleFactory();
+  static register(key, factory) {
+    _CacheProviderFactory.instance.register(key, factory);
+  }
+  static create(key, ...args) {
+    return _CacheProviderFactory.instance.create(key, ...args);
+  }
+};
+CacheProviderFactory.register("memory", (opt) => {
+  return new import_neko_cache.MemoryCacheProvider(opt);
+});
+CacheProviderFactory.register("redis", (opt) => {
+  return new import_neko_cache.RedisCacheProvider(opt);
+});
+CacheProviderFactory.register("file", (opt) => {
+  return new import_neko_cache.FileCacheProvider(opt);
+});
+CacheProviderFactory.register("disabled", (opt) => {
+  return new import_neko_cache.DisabledCacheProvider();
+});
 
 // src/facades.mts
+var import_neko_cache2 = require("@devbro/neko-cache");
 var router = (0, import_neko_helper.createSingleton)(() => new Router());
 var scheduler = (0, import_neko_helper.createSingleton)(() => {
   const rc = new import_neko_scheduler.Scheduler();
@@ -710,6 +736,17 @@ var queue = (0, import_neko_helper.createSingleton)((label) => {
   const rc = QueueFactory.create(queue_config.type, queue_config);
   return rc;
 });
+var cache = (0, import_neko_helper.createSingleton)((label) => {
+  const cache_config = import_neko_config.config.get(["caches", label].join("."));
+  if (!cache_config) {
+    throw new Error(`Cache configuration for '${label}' not found`);
+  }
+  const provider = CacheProviderFactory.create(
+    cache_config.type,
+    cache_config.config
+  );
+  return new import_neko_cache2.Cache(provider);
+});
 
 // src/app/console/queue/GenerateQueueMigrateCommand.mts
 var import_clipanion2 = require("clipanion");