@nocobase/plugin-field-sort 1.5.0-alpha.1

package/dist/node_modules/@nocobase/lock-manager/node_modules/streamsearch/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "streamsearch",
+  "version": "1.1.0",
+  "author": "Brian White <mscdex@mscdex.net>",
+  "description": "Streaming Boyer-Moore-Horspool searching for node.js",
+  "main": "./lib/sbmh.js",
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "devDependencies": {
+    "@mscdex/eslint-config": "^1.1.0",
+    "eslint": "^7.32.0"
+  },
+  "scripts": {
+    "test": "node test/test.js",
+    "lint": "eslint --cache --report-unused-disable-directives --ext=.js .eslintrc.js lib test",
+    "lint:fix": "npm run lint -- --fix"
+  },
+  "keywords": [
+    "stream",
+    "horspool",
+    "boyer-moore-horspool",
+    "boyer-moore",
+    "search"
+  ],
+  "licenses": [{
+    "type": "MIT",
+    "url": "http://github.com/mscdex/streamsearch/raw/master/LICENSE"
+  }],
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/mscdex/streamsearch.git"
+  }
+}

package/dist/node_modules/@nocobase/lock-manager/node_modules/streamsearch/test/test.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const assert = require('assert');
+
+const StreamSearch = require('../lib/sbmh.js');
+
+[
+  {
+    needle: '\r\n',
+    chunks: [
+      'foo',
+      ' bar',
+      '\r',
+      '\n',
+      'baz, hello\r',
+      '\n world.',
+      '\r\n Node.JS rules!!\r\n\r\n',
+    ],
+    expect: [
+      [false, 'foo'],
+      [false, ' bar'],
+      [ true, null],
+      [false, 'baz, hello'],
+      [ true, null],
+      [false, ' world.'],
+      [ true, null],
+      [ true, ' Node.JS rules!!'],
+      [ true, ''],
+    ],
+  },
+  {
+    needle: '---foobarbaz',
+    chunks: [
+      '---foobarbaz',
+      'asdf',
+      '\r\n',
+      '---foobarba',
+      '---foobar',
+      'ba',
+      '\r\n---foobarbaz--\r\n',
+    ],
+    expect: [
+      [ true, null],
+      [false, 'asdf'],
+      [false, '\r\n'],
+      [false, '---foobarba'],
+      [false, '---foobarba'],
+      [ true, '\r\n'],
+      [false, '--\r\n'],
+    ],
+  },
+].forEach((test, i) => {
+  console.log(`Running test #${i + 1}`);
+  const { needle, chunks, expect } = test;
+
+  const results = [];
+  const ss = new StreamSearch(Buffer.from(needle),
+                              (isMatch, data, start, end) => {
+    if (data)
+      data = data.toString('latin1', start, end);
+    else
+      data = null;
+    results.push([isMatch, data]);
+  });
+
+  for (const chunk of chunks)
+    ss.push(Buffer.from(chunk));
+
+  assert.deepStrictEqual(results, expect);
+});

package/dist/node_modules/@nocobase/lock-manager/package.json

@@ -0,0 +1 @@
+{"name":"@nocobase/lock-manager","version":"1.5.0-alpha.1","main":"lib/index.js","license":"AGPL-3.0","devDependencies":{"@nocobase/utils":"1.4.0-alpha.11","async-mutex":"^0.5.0"},"_lastModified":"2024-11-19T15:52:57.858Z"}

package/dist/node_modules/@nocobase/lock-manager/src/__tests__/lock-manager.test.ts

@@ -0,0 +1,169 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { Mutex, tryAcquire } from 'async-mutex';
+
+import { LockManager, LockAcquireError } from '../lock-manager';
+
+function sleep(ms = 1000) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+describe('lock manager', () => {
+  describe.skip('mutex example', () => {
+    it('acquire and release', async () => {
+      const order = [];
+      const lock = new Mutex();
+      const release1 = await lock.acquire();
+      order.push(1);
+      expect(release1).toBeDefined();
+      expect(lock.isLocked()).toBe(true);
+      setTimeout(async () => {
+        order.push(2);
+        await lock.release();
+        order.push(3);
+        expect(lock.isLocked()).toBe(true);
+      }, 200);
+      order.push(4);
+      const release2 = await lock.acquire();
+      order.push(5);
+      expect(lock.isLocked()).toBe(true);
+      await release2();
+      order.push(6);
+      expect(lock.isLocked()).toBe(false);
+      expect(order).toEqual([1, 4, 2, 3, 5, 6]);
+    });
+
+    it('tryAcquire', async () => {
+      const order = [];
+      const lock = new Mutex();
+      const l1 = tryAcquire(lock);
+      expect(l1.isLocked()).toBe(false);
+      const release1 = await lock.acquire();
+      expect(lock.isLocked()).toBe(true);
+      const l2 = tryAcquire(lock);
+      await expect(async () => {
+        const r2 = await l2.acquire();
+      }).rejects.toThrow();
+      await release1();
+    });
+  });
+
+  describe('local lock', () => {
+    const lockManager = new LockManager();
+
+    it('acquire and release', async () => {
+      const order = [];
+      const r1 = await lockManager.acquire('test');
+      order.push(1);
+      setTimeout(async () => {
+        order.push(2);
+        await r1();
+        order.push(3);
+      }, 200);
+      order.push(4);
+      const r2 = await lockManager.acquire('test');
+      order.push(5);
+      await r2();
+      order.push(6);
+      expect(order).toEqual([1, 4, 2, 3, 5, 6]);
+    });
+
+    it('acquire and release with timeout', async () => {
+      const order = [];
+      const r1 = await lockManager.acquire('test', 200);
+      order.push(1);
+      setTimeout(async () => {
+        order.push(2);
+        await r1();
+        order.push(3);
+      }, 400);
+      order.push(4);
+      const r2 = await lockManager.acquire('test', 200);
+      order.push(5);
+      await sleep(300);
+      await r2();
+      order.push(6);
+      expect(order).toEqual([1, 4, 5, 2, 3, 6]);
+    });
+
+    it('runExclusive', async () => {
+      const order = [];
+      setTimeout(async () => {
+        await lockManager.runExclusive('test', async () => {
+          order.push(1);
+          await sleep(100);
+          order.push(2);
+        });
+      }, 100);
+      order.push(3);
+      await lockManager.runExclusive('test', async () => {
+        order.push(4);
+        await sleep(400);
+        order.push(5);
+      });
+      order.push(6);
+      await sleep(200);
+      expect(order).toEqual([3, 4, 5, 1, 6, 2]);
+    });
+
+    it('runExclusive with timeout', async () => {
+      const order = [];
+      setTimeout(async () => {
+        await lockManager.runExclusive(
+          'test',
+          async () => {
+            order.push(1);
+            await sleep(200);
+            order.push(2);
+          },
+          200,
+        );
+      }, 100);
+      order.push(3);
+      await lockManager.runExclusive(
+        'test',
+        async () => {
+          order.push(4);
+          await sleep(400);
+          order.push(5);
+        },
+        200,
+      );
+      order.push(6);
+      await sleep(200);
+      expect(order).toEqual([3, 4, 5, 1, 6, 2]);
+    });
+
+    it('tryAcquire', async () => {
+      const release = await lockManager.acquire('test');
+      await expect(lockManager.tryAcquire('test')).rejects.toThrowError(LockAcquireError);
+      await release();
+      const lock = await lockManager.tryAcquire('test');
+      expect(lock.acquire).toBeTypeOf('function');
+      expect(lock.runExclusive).toBeTypeOf('function');
+
+      const order = [];
+      const r1 = await lock.acquire(200);
+      order.push(1);
+      setTimeout(async () => {
+        order.push(2);
+        await r1();
+        order.push(3);
+      }, 100);
+      const r2 = await lock.acquire(200);
+      order.push(4);
+      await sleep(300);
+      await r2();
+      expect(order).toEqual([1, 2, 3, 4]);
+    });
+  });
+});

package/dist/node_modules/@nocobase/lock-manager/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+export * from './lock-manager';
+export { default } from './lock-manager';

package/dist/node_modules/@nocobase/lock-manager/src/lock-manager.ts

@@ -0,0 +1,169 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { Registry } from '@nocobase/utils';
+import { Mutex, MutexInterface, E_CANCELED } from 'async-mutex';
+
+export type Releaser = () => void | Promise<void>;
+
+export interface ILock {
+  acquire(ttl: number): Releaser | Promise<Releaser>;
+  runExclusive<T>(fn: () => Promise<T>, ttl: number): Promise<T>;
+}
+
+export interface ILockAdapter {
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  acquire(key: string, ttl: number): Releaser | Promise<Releaser>;
+  runExclusive<T>(key: string, fn: () => Promise<T>, ttl: number): Promise<T>;
+  tryAcquire(key: string, timeout?: number): Promise<ILock>;
+}
+
+export class LockAbortError extends Error {
+  constructor(message, options) {
+    super(message, options);
+  }
+}
+
+export class LockAcquireError extends Error {
+  constructor(message, options?) {
+    super(message, options);
+  }
+}
+
+class LocalLockAdapter implements ILockAdapter {
+  static locks = new Map<string, MutexInterface>();
+
+  async connect() {}
+  async close() {}
+
+  private getLock(key: string): MutexInterface {
+    let lock = (<typeof LocalLockAdapter>this.constructor).locks.get(key);
+    if (!lock) {
+      lock = new Mutex();
+      (<typeof LocalLockAdapter>this.constructor).locks.set(key, lock);
+    }
+    return lock;
+  }
+
+  async acquire(key: string, ttl: number) {
+    const lock = this.getLock(key);
+    const release = (await lock.acquire()) as Releaser;
+    const timer = setTimeout(() => {
+      if (lock.isLocked()) {
+        release();
+      }
+    }, ttl);
+    return () => {
+      release();
+      clearTimeout(timer);
+    };
+  }
+
+  async runExclusive<T>(key: string, fn: () => Promise<T>, ttl: number): Promise<T> {
+    const lock = this.getLock(key);
+    let timer;
+    try {
+      timer = setTimeout(() => {
+        if (lock.isLocked()) {
+          lock.release();
+        }
+      }, ttl);
+      return lock.runExclusive(fn);
+    } catch (e) {
+      if (e === E_CANCELED) {
+        throw new LockAbortError('Lock aborted', { cause: E_CANCELED });
+      } else {
+        throw e;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  async tryAcquire(key: string) {
+    const lock = this.getLock(key);
+    if (lock.isLocked()) {
+      throw new LockAcquireError('lock is locked');
+    }
+    return {
+      acquire: async (ttl) => {
+        return this.acquire(key, ttl);
+      },
+      runExclusive: async (fn: () => Promise<any>, ttl) => {
+        return this.runExclusive(key, fn, ttl);
+      },
+    };
+  }
+}
+
+export interface LockAdapterConfig<C extends ILockAdapter = ILockAdapter> {
+  Adapter: new (...args: any[]) => C;
+  options?: Record<string, any>;
+}
+
+export interface LockManagerOptions {
+  defaultAdapter?: string;
+}
+
+export class LockManager {
+  private registry = new Registry<LockAdapterConfig>();
+  private adapters = new Map<string, ILockAdapter>();
+
+  constructor(private options: LockManagerOptions = {}) {
+    this.registry.register('local', {
+      Adapter: LocalLockAdapter,
+    });
+  }
+
+  registerAdapter(name: string, adapterConfig: LockAdapterConfig) {
+    this.registry.register(name, adapterConfig);
+  }
+
+  private async getAdapter(): Promise<ILockAdapter> {
+    const type = this.options.defaultAdapter || 'local';
+    let client = this.adapters.get(type);
+    if (!client) {
+      const adapter = this.registry.get(type);
+      if (!adapter) {
+        throw new Error(`Lock adapter "${type}" not registered`);
+      }
+
+      const { Adapter, options } = adapter;
+      client = new Adapter(options);
+      await client.connect();
+      this.adapters.set(type, client);
+    }
+
+    return client;
+  }
+
+  public async close() {
+    for (const client of this.adapters.values()) {
+      await client.close();
+    }
+  }
+
+  public async acquire(key: string, ttl = 500): Promise<Releaser> {
+    const client = await this.getAdapter();
+    return client.acquire(key, ttl);
+  }
+
+  public async runExclusive<T>(key: string, fn: () => Promise<T>, ttl = 500): Promise<T> {
+    const client = await this.getAdapter();
+    return client.runExclusive(key, fn, ttl);
+  }
+
+  public async tryAcquire(key: string) {
+    const client = await this.getAdapter();
+    return client.tryAcquire(key);
+  }
+}
+
+export default LockManager;

package/dist/server/action.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Collection, TargetKey, Model } from '@nocobase/database';
+import { Context } from '@nocobase/actions';
+import { SortField } from './sort-field';
+export declare function move(ctx: Context, next: any): Promise<any>;
+interface MoveOptions {
+    insertAfter?: boolean;
+}
+export declare class SortableCollection {
+    collection: Collection;
+    field: SortField;
+    scopeKey: string;
+    constructor(collection: Collection, fieldName?: string);
+    move(sourceInstanceId: TargetKey, targetInstanceId: TargetKey, options?: MoveOptions): Promise<void>;
+    changeScope(sourceInstanceId: TargetKey, targetScope: any, method?: string): Promise<void>;
+    sticky(sourceInstanceId: TargetKey): Promise<void>;
+    sameScopeMove(sourceInstance: Model, targetInstance: Model, options: MoveOptions): Promise<void>;
+}
+export {};

package/dist/server/action.js

@@ -0,0 +1,168 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var action_exports = {};
+__export(action_exports, {
+  SortableCollection: () => SortableCollection,
+  move: () => move
+});
+module.exports = __toCommonJS(action_exports);
+var import_database = require("@nocobase/database");
+var import_sort_field = require("./sort-field");
+async function move(ctx, next) {
+  const repository = ctx.getCurrentRepository();
+  if (repository.move) {
+    ctx.body = await repository.move(ctx.action.params);
+    return next();
+  }
+  if (!repository.database) {
+    return ctx.throw(new Error(`Repository can not handle action move for ${ctx.action.resourceName}`));
+  }
+  const { sourceId, targetId, targetScope, sticky, method } = ctx.action.params;
+  let sortField = ctx.action.params.sortField;
+  if (repository instanceof import_database.BelongsToManyRepository) {
+    throw new Error("Sorting association as 'belongs-to-many' type is not supported.");
+  }
+  if (repository instanceof import_database.HasManyRepository && !sortField) {
+    sortField = `${repository.association.foreignKey}Sort`;
+  }
+  const sortableCollection = new SortableCollection(repository.collection, sortField);
+  if (sourceId && targetId) {
+    await sortableCollection.move(sourceId, targetId, {
+      insertAfter: method === "insertAfter"
+    });
+  }
+  if (sourceId && targetScope) {
+    await sortableCollection.changeScope(sourceId, targetScope, method);
+  }
+  if (sourceId && sticky) {
+    await sortableCollection.sticky(sourceId);
+  }
+  ctx.body = "ok";
+  await next();
+}
+class SortableCollection {
+  collection;
+  field;
+  scopeKey;
+  constructor(collection, fieldName = "sort") {
+    this.collection = collection;
+    this.field = collection.getField(fieldName);
+    if (!(this.field instanceof import_sort_field.SortField)) {
+      throw new Error(`${fieldName} is not a sort field`);
+    }
+    this.scopeKey = this.field.get("scopeKey");
+  }
+  // insert source position to target position
+  async move(sourceInstanceId, targetInstanceId, options = {}) {
+    const sourceInstance = await this.collection.repository.findByTargetKey(sourceInstanceId);
+    const targetInstance = await this.collection.repository.findByTargetKey(targetInstanceId);
+    if (this.scopeKey && sourceInstance.get(this.scopeKey) !== targetInstance.get(this.scopeKey)) {
+      await sourceInstance.update({
+        [this.scopeKey]: targetInstance.get(this.scopeKey)
+      });
+    }
+    await this.sameScopeMove(sourceInstance, targetInstance, options);
+  }
+  async changeScope(sourceInstanceId, targetScope, method) {
+    const sourceInstance = await this.collection.repository.findByTargetKey(sourceInstanceId);
+    const targetScopeValue = targetScope[this.scopeKey];
+    if (targetScopeValue && sourceInstance.get(this.scopeKey) !== targetScopeValue) {
+      await sourceInstance.update(
+        {
+          [this.scopeKey]: targetScopeValue
+        },
+        {
+          silent: false
+        }
+      );
+      if (method === "prepend") {
+        await this.sticky(sourceInstanceId);
+      }
+    }
+  }
+  async sticky(sourceInstanceId) {
+    const sourceInstance = await this.collection.repository.findByTargetKey(sourceInstanceId);
+    await sourceInstance.update(
+      {
+        [this.field.get("name")]: 0
+      },
+      {
+        silent: true
+      }
+    );
+  }
+  async sameScopeMove(sourceInstance, targetInstance, options) {
+    const fieldName = this.field.get("name");
+    const sourceSort = sourceInstance.get(fieldName);
+    let targetSort = targetInstance.get(fieldName);
+    if (options.insertAfter) {
+      targetSort = targetSort + 1;
+    }
+    const scopeValue = this.scopeKey ? sourceInstance.get(this.scopeKey) : null;
+    let updateCondition;
+    let change;
+    if (targetSort > sourceSort) {
+      updateCondition = {
+        [import_database.Op.gt]: sourceSort,
+        [import_database.Op.lte]: targetSort
+      };
+      change = -1;
+    } else {
+      updateCondition = {
+        [import_database.Op.lt]: sourceSort,
+        [import_database.Op.gte]: targetSort
+      };
+      change = 1;
+    }
+    const where = {
+      [fieldName]: updateCondition
+    };
+    if (scopeValue) {
+      where[this.scopeKey] = {
+        [import_database.Op.eq]: scopeValue
+      };
+    }
+    await this.collection.model.increment(fieldName, {
+      where,
+      by: change,
+      silent: true
+    });
+    await sourceInstance.update(
+      {
+        [fieldName]: targetSort
+      },
+      {
+        silent: true
+      }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SortableCollection,
+  move
+});

package/dist/server/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export { default } from './plugin';
+export { move } from './action';