alepha 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -1,47 +1,173 @@
 'use strict';
 
+var cache = require('@alepha/cache');
 var core = require('@alepha/core');
-var messaging = require('@alepha/messaging');
-var orm = require('@alepha/orm');
+var store = require('@alepha/store');
+var postgres = require('@alepha/postgres');
+var queue = require('@alepha/queue');
 var redis = require('@alepha/redis');
+var scheduler = require('@alepha/scheduler');
 var server = require('@alepha/server');
-var store = require('@alepha/store');
+var topic = require('@alepha/topic');
+
+const lockDescriptorKey = "LOCK";
+const lock = (options) => core.createDescriptorValue({
+  kind: lockDescriptorKey,
+  options,
+  apply: (...args) => {
+    return options.handler(...args);
+  }
+});
+lock[core.KIND] = lockDescriptorKey;
 
+class LockDescriptorProvider {
+  alepha = core.inject(core.Alepha);
+  dateTimeProvider = core.inject(core.DateTimeProvider);
+  storeProvider = core.inject(store.StoreProvider);
+  log = core.logger();
+  id = this.alepha.id;
+  configure = core.hook({
+    name: "configure",
+    handler: (alepha) => {
+      const descriptors = alepha.getDescriptorValues(lock);
+      for (const { instance, key, value } of descriptors) {
+        const { options } = value;
+        const item = {
+          options,
+          key: (...args) => {
+            if (options.key) {
+              if (typeof options.key === "string") {
+                return options.key;
+              }
+              return options.key(...args);
+            }
+            return key;
+          },
+          maxDuration: options.maxDuration ?? 60
+        };
+        const run = (...args) => this.run(item, ...args);
+        core.updateDescriptorValue(value, instance, {
+          apply: run
+        });
+      }
+    }
+  });
+  /**
+   * Run the lock handler.
+   *
+   * @param value
+   * @param args
+   */
+  async run(value, ...args) {
+    const key = `lock:${value.key(...args)}`;
+    const handler = value.options.handler;
+    const lock2 = await this.lock(key, value);
+    if (lock2.id !== this.id) {
+      return;
+    }
+    if (lock2.endedAt) {
+      return;
+    }
+    try {
+      await handler(...args);
+    } finally {
+      const gracePeriod = value.options.gracePeriod ? typeof value.options.gracePeriod === "function" ? value.options.gracePeriod(...args) : value.options.gracePeriod : void 0;
+      if (gracePeriod) {
+        await this.storeProvider.set(
+          key,
+          `${this.id},${lock2.createdAt.toISO()},${this.dateTimeProvider.nowISOString()}`,
+          {
+            px: this.dateTimeProvider.duration(gracePeriod).as("milliseconds")
+          }
+        );
+      } else {
+        await this.storeProvider.del(key);
+      }
+    }
+  }
+  async lock(key, item) {
+    const value = await this.storeProvider.set(
+      key,
+      `${this.id},${this.dateTimeProvider.nowISOString()}`,
+      {
+        nx: true,
+        px: this.dateTimeProvider.duration(item.maxDuration).as("milliseconds")
+      }
+    );
+    const [id, createdAtStr, endedAtStr] = value.split(",");
+    const createdAt = core.DateTime.fromISO(createdAtStr);
+    const endedAt = endedAtStr ? core.DateTime.fromISO(endedAtStr) : void 0;
+    return {
+      id,
+      createdAt,
+      endedAt
+    };
+  }
+}
 
+class LockModule {
+  alepha = core.inject(core.Alepha);
+  constructor() {
+    this.alepha.register(store.StoreModule);
+    this.alepha.register(LockDescriptorProvider);
+  }
+}
+core.autoInject(lock, LockModule);
 
+exports.LockDescriptorProvider = LockDescriptorProvider;
+exports.lock = lock;
+exports.lockDescriptorKey = lockDescriptorKey;
+Object.keys(cache).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return cache[k]; }
+  });
+});
 Object.keys(core).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return core[k]; }
-	});
-});
-Object.keys(messaging).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return messaging[k]; }
-	});
-});
-Object.keys(orm).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return orm[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return core[k]; }
+  });
+});
+Object.keys(store).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return store[k]; }
+  });
+});
+Object.keys(postgres).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return postgres[k]; }
+  });
+});
+Object.keys(queue).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return queue[k]; }
+  });
 });
 Object.keys(redis).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return redis[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return redis[k]; }
+  });
+});
+Object.keys(scheduler).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return scheduler[k]; }
+  });
 });
 Object.keys(server).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return server[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return server[k]; }
+  });
 });
-Object.keys(store).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return store[k]; }
-	});
+Object.keys(topic).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return topic[k]; }
+  });
 });

package/dist/index.d.cts

@@ -1,6 +1,76 @@
+export * from '@alepha/cache';
+import * as _alepha_core from '@alepha/core';
+import { AsyncFn, DurationLike, KIND, Alepha, DateTimeProvider, DateTime } from '@alepha/core';
 export * from '@alepha/core';
-export * from '@alepha/messaging';
-export * from '@alepha/orm';
+import { StoreProvider } from '@alepha/store';
+export * from '@alepha/store';
+export * from '@alepha/postgres';
+export * from '@alepha/queue';
 export * from '@alepha/redis';
+export * from '@alepha/scheduler';
 export * from '@alepha/server';
-export * from '@alepha/store';
+export * from '@alepha/topic';
+
+interface LockDescriptorOptions<TFunc extends AsyncFn> {
+    /**
+     * Function executed when the lock is acquired.
+     */
+    handler: TFunc;
+    key?: string | ((...args: Parameters<TFunc>) => string);
+    maxDuration?: DurationLike;
+    gracePeriod?: DurationLike | ((...args: Parameters<TFunc>) => DurationLike | undefined);
+}
+declare const lockDescriptorKey = "LOCK";
+/**
+ * Lock descriptor
+ *
+ * Make sure that only one instance of the handler is running at a time.
+ *
+ * When connected to a remote store, the lock is shared across all processes.
+ *
+ * @param options
+ */
+declare const lock: {
+    <TFunc extends AsyncFn>(options: LockDescriptorOptions<TFunc>): _alepha_core.DescriptorInstance<{
+        kind: string;
+        options: LockDescriptorOptions<TFunc>;
+        apply: (...args: Parameters<TFunc>) => Promise<void>;
+    }>;
+    [KIND]: string;
+};
+
+declare class LockDescriptorProvider {
+    protected readonly alepha: Alepha;
+    protected readonly dateTimeProvider: DateTimeProvider;
+    protected readonly storeProvider: StoreProvider;
+    protected readonly log: _alepha_core.Logger;
+    protected readonly id: string;
+    protected readonly configure: _alepha_core.DescriptorInstance<{
+        kind: string;
+        options: {
+            name: "configure";
+            handler: (app: Alepha) => _alepha_core.Async<void>;
+        };
+        apply: (arg: Alepha) => _alepha_core.Async<void>;
+    }>;
+    /**
+     * Run the lock handler.
+     *
+     * @param value
+     * @param args
+     */
+    protected run(value: LockDescriptorValue, ...args: any[]): Promise<void>;
+    protected lock(key: string, item: LockDescriptorValue): Promise<LockObject>;
+}
+interface LockDescriptorValue {
+    options: LockDescriptorOptions<AsyncFn>;
+    key: (...args: any[]) => string;
+    maxDuration: DurationLike;
+}
+interface LockObject {
+    id: string;
+    createdAt: DateTime;
+    endedAt?: DateTime;
+}
+
+export { type LockDescriptorOptions, LockDescriptorProvider, type LockDescriptorValue, type LockObject, lock, lockDescriptorKey };

package/dist/index.d.mts

@@ -1,6 +1,76 @@
+export * from '@alepha/cache';
+import * as _alepha_core from '@alepha/core';
+import { AsyncFn, DurationLike, KIND, Alepha, DateTimeProvider, DateTime } from '@alepha/core';
 export * from '@alepha/core';
-export * from '@alepha/messaging';
-export * from '@alepha/orm';
+import { StoreProvider } from '@alepha/store';
+export * from '@alepha/store';
+export * from '@alepha/postgres';
+export * from '@alepha/queue';
 export * from '@alepha/redis';
+export * from '@alepha/scheduler';
 export * from '@alepha/server';
-export * from '@alepha/store';
+export * from '@alepha/topic';
+
+interface LockDescriptorOptions<TFunc extends AsyncFn> {
+    /**
+     * Function executed when the lock is acquired.
+     */
+    handler: TFunc;
+    key?: string | ((...args: Parameters<TFunc>) => string);
+    maxDuration?: DurationLike;
+    gracePeriod?: DurationLike | ((...args: Parameters<TFunc>) => DurationLike | undefined);
+}
+declare const lockDescriptorKey = "LOCK";
+/**
+ * Lock descriptor
+ *
+ * Make sure that only one instance of the handler is running at a time.
+ *
+ * When connected to a remote store, the lock is shared across all processes.
+ *
+ * @param options
+ */
+declare const lock: {
+    <TFunc extends AsyncFn>(options: LockDescriptorOptions<TFunc>): _alepha_core.DescriptorInstance<{
+        kind: string;
+        options: LockDescriptorOptions<TFunc>;
+        apply: (...args: Parameters<TFunc>) => Promise<void>;
+    }>;
+    [KIND]: string;
+};
+
+declare class LockDescriptorProvider {
+    protected readonly alepha: Alepha;
+    protected readonly dateTimeProvider: DateTimeProvider;
+    protected readonly storeProvider: StoreProvider;
+    protected readonly log: _alepha_core.Logger;
+    protected readonly id: string;
+    protected readonly configure: _alepha_core.DescriptorInstance<{
+        kind: string;
+        options: {
+            name: "configure";
+            handler: (app: Alepha) => _alepha_core.Async<void>;
+        };
+        apply: (arg: Alepha) => _alepha_core.Async<void>;
+    }>;
+    /**
+     * Run the lock handler.
+     *
+     * @param value
+     * @param args
+     */
+    protected run(value: LockDescriptorValue, ...args: any[]): Promise<void>;
+    protected lock(key: string, item: LockDescriptorValue): Promise<LockObject>;
+}
+interface LockDescriptorValue {
+    options: LockDescriptorOptions<AsyncFn>;
+    key: (...args: any[]) => string;
+    maxDuration: DurationLike;
+}
+interface LockObject {
+    id: string;
+    createdAt: DateTime;
+    endedAt?: DateTime;
+}
+
+export { type LockDescriptorOptions, LockDescriptorProvider, type LockDescriptorValue, type LockObject, lock, lockDescriptorKey };

package/dist/index.mjs

@@ -1,6 +1,117 @@
+export * from '@alepha/cache';
+import { KIND, autoInject, createDescriptorValue, inject, Alepha, DateTimeProvider, logger, hook, updateDescriptorValue, DateTime } from '@alepha/core';
 export * from '@alepha/core';
-export * from '@alepha/messaging';
-export * from '@alepha/orm';
+import { StoreProvider, StoreModule } from '@alepha/store';
+export * from '@alepha/store';
+export * from '@alepha/postgres';
+export * from '@alepha/queue';
 export * from '@alepha/redis';
+export * from '@alepha/scheduler';
 export * from '@alepha/server';
-export * from '@alepha/store';
+export * from '@alepha/topic';
+
+const lockDescriptorKey = "LOCK";
+const lock = (options) => createDescriptorValue({
+  kind: lockDescriptorKey,
+  options,
+  apply: (...args) => {
+    return options.handler(...args);
+  }
+});
+lock[KIND] = lockDescriptorKey;
+
+class LockDescriptorProvider {
+  alepha = inject(Alepha);
+  dateTimeProvider = inject(DateTimeProvider);
+  storeProvider = inject(StoreProvider);
+  log = logger();
+  id = this.alepha.id;
+  configure = hook({
+    name: "configure",
+    handler: (alepha) => {
+      const descriptors = alepha.getDescriptorValues(lock);
+      for (const { instance, key, value } of descriptors) {
+        const { options } = value;
+        const item = {
+          options,
+          key: (...args) => {
+            if (options.key) {
+              if (typeof options.key === "string") {
+                return options.key;
+              }
+              return options.key(...args);
+            }
+            return key;
+          },
+          maxDuration: options.maxDuration ?? 60
+        };
+        const run = (...args) => this.run(item, ...args);
+        updateDescriptorValue(value, instance, {
+          apply: run
+        });
+      }
+    }
+  });
+  /**
+   * Run the lock handler.
+   *
+   * @param value
+   * @param args
+   */
+  async run(value, ...args) {
+    const key = `lock:${value.key(...args)}`;
+    const handler = value.options.handler;
+    const lock2 = await this.lock(key, value);
+    if (lock2.id !== this.id) {
+      return;
+    }
+    if (lock2.endedAt) {
+      return;
+    }
+    try {
+      await handler(...args);
+    } finally {
+      const gracePeriod = value.options.gracePeriod ? typeof value.options.gracePeriod === "function" ? value.options.gracePeriod(...args) : value.options.gracePeriod : void 0;
+      if (gracePeriod) {
+        await this.storeProvider.set(
+          key,
+          `${this.id},${lock2.createdAt.toISO()},${this.dateTimeProvider.nowISOString()}`,
+          {
+            px: this.dateTimeProvider.duration(gracePeriod).as("milliseconds")
+          }
+        );
+      } else {
+        await this.storeProvider.del(key);
+      }
+    }
+  }
+  async lock(key, item) {
+    const value = await this.storeProvider.set(
+      key,
+      `${this.id},${this.dateTimeProvider.nowISOString()}`,
+      {
+        nx: true,
+        px: this.dateTimeProvider.duration(item.maxDuration).as("milliseconds")
+      }
+    );
+    const [id, createdAtStr, endedAtStr] = value.split(",");
+    const createdAt = DateTime.fromISO(createdAtStr);
+    const endedAt = endedAtStr ? DateTime.fromISO(endedAtStr) : void 0;
+    return {
+      id,
+      createdAt,
+      endedAt
+    };
+  }
+}
+
+class LockModule {
+  alepha = inject(Alepha);
+  constructor() {
+    this.alepha.register(StoreModule);
+    this.alepha.register(LockDescriptorProvider);
+  }
+}
+autoInject(lock, LockModule);
+
+export { LockDescriptorProvider, lock, lockDescriptorKey };

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "alepha",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
   "dependencies": {
-    "@alepha/core": "0.2.0",
-    "@alepha/messaging": "0.2.0",
-    "@alepha/orm": "0.2.0",
-    "@alepha/redis": "0.2.0",
-    "@alepha/server": "0.2.0",
-    "@alepha/store": "0.2.0"
+    "@alepha/cache": "0.3.0",
+    "@alepha/core": "0.3.0",
+    "@alepha/postgres": "0.3.0",
+    "@alepha/queue": "0.3.0",
+    "@alepha/redis": "0.3.0",
+    "@alepha/scheduler": "0.3.0",
+    "@alepha/server": "0.3.0",
+    "@alepha/store": "0.3.0",
+    "@alepha/topic": "0.3.0"
   },
   "devDependencies": {
     "pkgroll": "^2.6.0",

package/src/index.ts

@@ -1,6 +1,10 @@
+export * from "@alepha/cache";
 export * from "@alepha/core";
-export * from "@alepha/messaging";
-export * from "@alepha/orm";
+export * from "@alepha/lock";
+export * from "@alepha/postgres";
+export * from "@alepha/queue";
 export * from "@alepha/redis";
+export * from "@alepha/scheduler";
 export * from "@alepha/server";
 export * from "@alepha/store";
+export * from "@alepha/topic";