@adminforth/auto-remove 1.0.2

package/.woodpecker/buildRelease.sh

@@ -0,0 +1,13 @@
+
+#!/bin/bash
+
+# write npm run output both to console and to build.log
+npm run build 2>&1 | tee build.log
+build_status=${PIPESTATUS[0]}
+
+# if exist status from the npm run build is not 0
+# then exit with the status code from the npm run build
+if [ $build_status -ne 0 ]; then
+  echo "Build failed. Exiting with status code $build_status"
+  exit $build_status
+fi

package/.woodpecker/buildSlackNotify.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+
+set -x
+
+COMMIT_SHORT_SHA=$(echo $CI_COMMIT_SHA | cut -c1-8)
+
+STATUS=${1}  
+
+
+if [ "$STATUS" = "success" ]; then
+  MESSAGE="Did a build without issues on \`$CI_REPO_NAME/$CI_COMMIT_BRANCH\`. Commit: _${CI_COMMIT_MESSAGE}_ (<$CI_COMMIT_URL|$COMMIT_SHORT_SHA>)"
+
+  curl  -s -X POST -H "Content-Type: application/json" -d '{
+    "username": "'"$CI_COMMIT_AUTHOR"'",
+    "icon_url": "'"$CI_COMMIT_AUTHOR_AVATAR"'",
+    "attachments": [
+      {
+          "mrkdwn_in": ["text", "pretext"],
+          "color": "#36a64f",
+          "text": "'"$MESSAGE"'"
+      }
+    ]
+  }' "$DEVELOPERS_SLACK_WEBHOOK"
+  exit 0
+fi
+export BUILD_LOG=$(cat ./build.log)
+
+BUILD_LOG=$(echo $BUILD_LOG | sed 's/"/\\"/g')
+
+MESSAGE="Broke \`$CI_REPO_NAME/$CI_COMMIT_BRANCH\` with commit _${CI_COMMIT_MESSAGE}_ (<$CI_COMMIT_URL|$COMMIT_SHORT_SHA>)"
+CODE_BLOCK="\`\`\`$BUILD_LOG\n\`\`\`"
+
+echo "Sending slack message to developers $MESSAGE"
+# Send the message
+curl -sS -X POST -H "Content-Type: application/json" -d '{
+  "username": "'"$CI_COMMIT_AUTHOR"'",
+  "icon_url": "'"$CI_COMMIT_AUTHOR_AVATAR"'",
+  "attachments": [
+    {
+        "mrkdwn_in": ["text", "pretext"],
+        "color": "#8A1C12",
+        "text": "'"$CODE_BLOCK"'",
+        "pretext": "'"$MESSAGE"'"
+    }
+  ]
+}' "$DEVELOPERS_SLACK_WEBHOOK" 2>&1

package/.woodpecker/release.yml

@@ -0,0 +1,57 @@
+clone:
+  git:
+    image: woodpeckerci/plugin-git
+    settings:
+      partial: false
+      depth: 5
+
+steps:
+  init-secrets:
+    when:
+      - event: push
+    image: infisical/cli
+    environment:
+      INFISICAL_TOKEN:
+        from_secret: VAULT_TOKEN
+    commands:
+      - infisical export --domain https://vault.devforth.io/api --format=dotenv-export --env="prod" > /woodpecker/deploy.vault.env
+
+  build:
+    image: devforth/node20-pnpm:latest
+    when:
+      - event: push
+    commands:
+      - apt update && apt install -y rsync
+      - . /woodpecker/deploy.vault.env   
+      - pnpm install
+      - /bin/bash ./.woodpecker/buildRelease.sh
+      - npm audit signatures
+
+  release:
+    image: devforth/node20-pnpm:latest
+    when:
+      - event:
+          - push
+        branch:
+          - main
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - pnpm exec semantic-release
+
+  slack-on-failure:
+    image: curlimages/curl
+    when:
+      - event: push
+        status: [failure]
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - /bin/sh ./.woodpecker/buildSlackNotify.sh failure
+      
+  slack-on-success: 
+    image: curlimages/curl
+    when:
+      - event: push
+        status: [success]
+    commands:
+      - . /woodpecker/deploy.vault.env
+      - /bin/sh ./.woodpecker/buildSlackNotify.sh success

package/README.md

@@ -0,0 +1,104 @@
+# Auto Remove Plugin
+
+This plugin removes records from resources based on **count-based** or **time-based** rules.
+
+It is designed for cleaning up:
+
+* old records
+* logs
+* demo/test data
+* temporary entities
+
+---
+
+## Installation
+
+To install the plugin:
+
+```ts
+npm install @adminforth/auto-remove
+```
+
+Import it into your resource:
+```ts
+import AutoRemovePlugin from '../../plugins/adminforth-auto-remove/index.js';
+```
+
+## Plugin Options
+
+```ts
+export interface PluginOptions {
+ createdAtField: string;
+
+  /**
+   * - count-based: Delete items > keepAtLeast
+   * - time-based: Delete age > deleteOlderThan
+   */
+  mode: AutoRemoveMode;
+
+  /**
+   * for count-based mode (100', '1k', '10k', '1m')
+   */
+  keepAtLeast?: HumanNumber;
+
+  /**
+   * Minimum number of items to always keep in count-based mode.
+   * This acts as a safety threshold together with `keepAtLeast`.
+   * Example formats: '100', '1k', '10k', '1m'.
+   * 
+   * Validation ensures that minItemsKeep <= keepAtLeast. 
+  */
+  minItemsKeep?: HumanNumber;
+
+  /**
+   * Max age of item for time-based mode ('1d', '7d', '1mo', '1y')
+   */
+  deleteOlderThan?: HumanDuration;
+
+  /**
+   * Interval for running cleanup (e.g. '1h', '1d')
+   * Default '1d'
+   */
+  interval?: HumanDuration;
+}
+```
+---
+
+## Usage
+To use the plugin, add it to your resource file. Here's an example:
+
+for count-based mode
+```ts
+new AutoRemovePlugin({
+        createdAtField: 'created_at',   
+        mode: 'count-based',            
+        keepAtLeast: '200',                  
+        interval: '1mo',                  
+        minItemsKeep: '180',       
+      }),
+```
+
+for time-based mode
+```ts
+new AutoRemovePlugin({
+        createdAtField: 'created_at',
+        mode: 'time-based',
+        deleteOlderThan: '3mo',
+        interval: '1mo',  
+      }),
+```
+
+---
+
+## Result
+After running **AutoRemovePlugin**, old or excess records are deleted automatically:
+
+- **Count-based mode:** keeps the newest `keepAtLeast` records, deletes older ones.  
+  Example: `keepAtLeast = 500` → table with 650 records deletes 150 oldest.
+
+- **Time-based mode:** deletes records older than `deleteOlderThan`.  
+  Example: `deleteOlderThan = '7d'` → removes records older than 7 days.
+
+- **Manual cleanup:** `POST /plugin/{pluginInstanceId}/cleanup`, returns `{ "ok": true }`.
+
+Logs show how many records were removed per run.

package/build.log

@@ -0,0 +1,10 @@
+
+> @adminforth/auto-remove@1.0.0 build
+> tsc && rsync -av --exclude 'node_modules' custom dist/
+
+sending incremental file list
+custom/
+custom/tsconfig.json
+
+sent 451 bytes  received 39 bytes  980.00 bytes/sec
+total size is 308  speedup is 0.63

package/custom/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".", // This should point to your project root
+    "paths": {
+      "@/*": [
+        "../node_modules/adminforth/dist/spa/src/*"
+      ],
+      "*": [
+        "../node_modules/adminforth/dist/spa/node_modules/*"
+      ],
+      "@@/*": [
+        "."
+      ]
+    }
+  }
+}

package/dist/custom/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".", // This should point to your project root
+    "paths": {
+      "@/*": [
+        "../node_modules/adminforth/dist/spa/src/*"
+      ],
+      "*": [
+        "../node_modules/adminforth/dist/spa/node_modules/*"
+      ],
+      "@@/*": [
+        "."
+      ]
+    }
+  }
+}

package/dist/index.js

@@ -0,0 +1,119 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AdminForthPlugin, Sorts, AdminForthDataTypes } from "adminforth";
+import { parseHumanNumber } from './utils/parseNumber.js';
+import { parseDuration } from './utils/parseDuration.js';
+export default class AutoRemovePlugin extends AdminForthPlugin {
+    constructor(options) {
+        super(options, import.meta.url);
+        this.options = options;
+        this.shouldHaveSingleInstancePerWholeApp = () => false;
+    }
+    instanceUniqueRepresentation(pluginOptions) {
+        return `single`;
+    }
+    modifyResourceConfig(adminforth, resourceConfig) {
+        const _super = Object.create(null, {
+            modifyResourceConfig: { get: () => super.modifyResourceConfig }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.modifyResourceConfig.call(this, adminforth, resourceConfig);
+            if (resourceConfig) {
+                this.resource = resourceConfig;
+            }
+            const intervalMs = parseDuration(this.options.interval || '1d');
+            this.timer = setInterval(() => {
+                this.runCleanup(adminforth).catch(console.error);
+            }, intervalMs);
+        });
+    }
+    validateConfigAfterDiscover(adminforth, resourceConfig) {
+        const col = resourceConfig.columns.find(c => c.name === this.options.createdAtField);
+        if (!col)
+            throw new Error(`Field "${this.options.createdAtField}" not found in resource "${resourceConfig.label}", but required`);
+        if (![AdminForthDataTypes.DATE, AdminForthDataTypes.DATETIME].includes(col.type)) {
+            throw new Error(`Field "${this.options.createdAtField}" in resource "${resourceConfig.label}" must be of type DATE or DATETIME`);
+        }
+        if (this.options.mode !== 'time-based' && this.options.mode !== 'count-based') {
+            throw new Error(`wrong delete mode "${this.options.mode}", please set "time-based" or "count-based"`);
+        }
+        if (this.options.mode === 'count-based') {
+            if (!this.options.keepAtLeast) {
+                throw new Error('keepAtLeast is required for count-based mode');
+            }
+            if (this.options.minItemsKeep && parseHumanNumber(this.options.minItemsKeep) > parseHumanNumber(this.options.keepAtLeast)) {
+                throw new Error(`Option "minItemsKeep" (${this.options.minItemsKeep}) cannot be greater than "keepAtLeast" (${this.options.keepAtLeast}). Please set "minItemsKeep" less than or equal to "keepAtLeast"`);
+            }
+        }
+        if (this.options.mode === 'time-based' && !this.options.deleteOlderThan) {
+            throw new Error('deleteOlderThan is required for time-based mode');
+        }
+        if (this.options.mode === 'count-based' && !this.options.minItemsKeep) {
+            throw new Error('minItemsKeep is required');
+        }
+    }
+    runCleanup(adminforth) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.options.mode === 'count-based') {
+                    yield this.cleanupByCount(adminforth, this.resourceConfig);
+                }
+                else {
+                    yield this.cleanupByTime(adminforth, this.resourceConfig);
+                }
+            }
+            catch (err) {
+                console.error('AutoRemovePlugin runCleanup error:', err);
+            }
+        });
+    }
+    cleanupByCount(adminforth, resourceConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const limit = parseHumanNumber(this.options.keepAtLeast);
+            const resource = adminforth.resource(this.resource.resourceId);
+            const allRecords = yield resource.list([], null, null, [Sorts.ASC(this.options.createdAtField)]);
+            if (allRecords.length <= limit)
+                return;
+            const toDelete = allRecords.slice(0, allRecords.length - limit);
+            const pkColumn = this.resource.columns.find(c => c.primaryKey).name;
+            const ids = toDelete.map(r => r[pkColumn]);
+            yield resource.dataConnector.deleteMany({ resource: resourceConfig, recordIds: ids });
+            console.log(`AutoRemovePlugin: deleted ${toDelete.length} records due to count-based limit`);
+        });
+    }
+    cleanupByTime(adminforth, resourceConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maxAgeMs = parseDuration(this.options.deleteOlderThan);
+            const threshold = Date.now() - maxAgeMs;
+            const resource = adminforth.resource(this.resource.resourceId);
+            const allRecords = yield resource.list([], null, null, [Sorts.ASC(this.options.createdAtField)]);
+            const toDelete = allRecords.filter(r => new Date(r[this.options.createdAtField]).getTime() < threshold);
+            const pkColumn = this.resource.columns.find(c => c.primaryKey).name;
+            const ids = toDelete.map(r => r[pkColumn]);
+            yield resource.dataConnector.deleteMany({ resource: resourceConfig, recordIds: ids });
+            console.log(`AutoRemovePlugin: deleted ${toDelete.length} records due to time-based limit`);
+        });
+    }
+    setupEndpoints(server) {
+        server.endpoint({
+            method: 'POST',
+            path: `/plugin/${this.pluginInstanceId}/cleanup`,
+            handler: () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.runCleanup(this.adminforth);
+                    return { ok: true };
+                }
+                catch (err) {
+                    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+                }
+            })
+        });
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/parseDuration.js

@@ -0,0 +1,17 @@
+const UNITS = {
+    s: 1000,
+    m: 60000,
+    h: 3600000,
+    d: 86400000,
+    w: 604800000,
+    mo: 2592000000,
+    y: 31536000000,
+};
+export function parseDuration(value) {
+    const match = value.match(/^(\d+)\s*(s|m|h|d|w|mo|y)$/);
+    if (!match) {
+        throw new Error(`Invalid duration format: ${value}`);
+    }
+    const [, amount, unit] = match;
+    return Number(amount) * UNITS[unit];
+}

package/dist/utils/parseNumber.js

@@ -0,0 +1,10 @@
+export function parseHumanNumber(value) {
+    const v = value.toLowerCase().trim();
+    if (v.endsWith('kk'))
+        return Number(v.slice(0, -2)) * 1000000;
+    if (v.endsWith('k'))
+        return Number(v.slice(0, -1)) * 1000;
+    if (v.endsWith('m'))
+        return Number(v.slice(0, -1)) * 1000000;
+    return Number(v);
+}

package/index.ts

@@ -0,0 +1,119 @@
+import { AdminForthPlugin, Filters, Sorts, AdminForthDataTypes } from "adminforth";
+import type { IAdminForth, IHttpServer, AdminForthResource } from "adminforth";
+import type { PluginOptions } from './types.js';
+import { parseHumanNumber } from './utils/parseNumber.js';
+import { parseDuration } from './utils/parseDuration.js';
+
+export default class AutoRemovePlugin extends AdminForthPlugin {
+  options: PluginOptions;
+  resource?: AdminForthResource;
+  timer?: NodeJS.Timeout;
+
+  constructor(options: PluginOptions) {
+    super(options, import.meta.url);
+    this.options = options;
+    this.shouldHaveSingleInstancePerWholeApp = () => false;
+  }
+
+  instanceUniqueRepresentation(pluginOptions: any) : string {
+    return `single`;
+  }
+
+  async modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
+    super.modifyResourceConfig(adminforth, resourceConfig);
+
+    if (resourceConfig) {
+      this.resource = resourceConfig;
+    }
+
+    const intervalMs = parseDuration(this.options.interval || '1d');
+    this.timer = setInterval(() => {
+      this.runCleanup(adminforth).catch(console.error);
+    }, intervalMs);
+  }
+
+  validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
+    const col = resourceConfig.columns.find(c => c.name === this.options.createdAtField);
+    if (!col) throw new Error(`Field "${this.options.createdAtField}" not found in resource "${resourceConfig.label}", but required`);
+    if (![AdminForthDataTypes.DATE, AdminForthDataTypes.DATETIME].includes(col.type!)) {
+      throw new Error(`Field "${this.options.createdAtField}" in resource "${resourceConfig.label}" must be of type DATE or DATETIME`);
+    }
+    if (this.options.mode !== 'time-based' && this.options.mode !== 'count-based'){
+      throw new Error(`wrong delete mode "${this.options.mode}", please set "time-based" or "count-based"`);
+    }
+    if (this.options.mode === 'count-based') {
+      if (!this.options.keepAtLeast) {
+        throw new Error('keepAtLeast is required for count-based mode');
+      }
+      if (this.options.minItemsKeep && parseHumanNumber(this.options.minItemsKeep) > parseHumanNumber(this.options.keepAtLeast)) {
+        throw new Error(
+          `Option "minItemsKeep" (${this.options.minItemsKeep}) cannot be greater than "keepAtLeast" (${this.options.keepAtLeast}). Please set "minItemsKeep" less than or equal to "keepAtLeast"`
+        );
+      }
+    }
+    if (this.options.mode === 'time-based' && !this.options.deleteOlderThan) {
+      throw new Error('deleteOlderThan is required for time-based mode');
+    }
+    if (this.options.mode === 'count-based' && !this.options.minItemsKeep){
+      throw new Error('minItemsKeep is required');
+    }
+  }
+
+  private async runCleanup(adminforth: IAdminForth) {
+    try {
+      if (this.options.mode === 'count-based') {
+        await this.cleanupByCount(adminforth, this.resourceConfig);
+      } else {
+        await this.cleanupByTime(adminforth, this.resourceConfig);
+      }
+    } catch (err) {
+      console.error('AutoRemovePlugin runCleanup error:', err);
+    }
+  }
+  
+  private async cleanupByCount(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
+    const limit = parseHumanNumber(this.options.keepAtLeast!);
+    const resource = adminforth.resource(this.resource.resourceId);
+
+    const allRecords = await resource.list([], null, null, [Sorts.ASC(this.options.createdAtField)]);
+    if (allRecords.length <= limit) return;
+
+    const toDelete = allRecords.slice(0, allRecords.length - limit);
+    const pkColumn = this.resource.columns.find(c => c.primaryKey)!.name;
+    const ids = toDelete.map(r => r[pkColumn]);
+
+    await resource.dataConnector.deleteMany({ resource: resourceConfig, recordIds: ids });
+
+    console.log(`AutoRemovePlugin: deleted ${toDelete.length} records due to count-based limit`);
+  }
+
+  private async cleanupByTime(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
+    const maxAgeMs = parseDuration(this.options.deleteOlderThan!);
+    const threshold = Date.now() - maxAgeMs;
+    const resource = adminforth.resource(this.resource.resourceId);
+
+    const allRecords = await resource.list([], null, null, [Sorts.ASC(this.options.createdAtField)]);
+    const toDelete = allRecords.filter(r => new Date(r[this.options.createdAtField]).getTime() < threshold);
+
+    const pkColumn = this.resource.columns.find(c => c.primaryKey)!.name;
+    const ids = toDelete.map(r => r[pkColumn]);
+    await resource.dataConnector.deleteMany({ resource: resourceConfig, recordIds: ids });
+
+    console.log(`AutoRemovePlugin: deleted ${toDelete.length} records due to time-based limit`);
+  }
+
+  setupEndpoints(server: IHttpServer) {
+    server.endpoint({
+      method: 'POST',
+      path: `/plugin/${this.pluginInstanceId}/cleanup`,
+      handler: async () => {
+        try {
+          await this.runCleanup(this.adminforth);
+          return { ok: true };
+        } catch (err) {
+          return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    });
+  }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@adminforth/auto-remove",
+  "version": "1.0.2",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/node": "latest",
+    "semantic-release": "^24.2.1",
+    "semantic-release-slack-bot": "^4.0.2",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "adminforth": "2.25.4"
+  },
+  "release": {
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "semantic-release-slack-bot",
+        {
+          "packageName": "@adminforth/auto-remove",
+          "notifyOnSuccess": true,
+          "notifyOnFail": true,
+          "slackIcon": ":package:",
+          "markdownReleaseNotes": true
+        }
+      ]
+    ],
+    "branches": [
+      "main",
+      {
+        "name": "next",
+        "prerelease": true
+      }
+    ]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+      "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include*/ 
+      "module": "node16",                                /* Specify what module code is generated. */
+      "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+      "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules.  */
+      "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+      "strict": false,                                     /* Enable all strict type-checking options. */
+      "skipLibCheck": true,                                 /* Skip type checking all .d.ts files. */
+    },
+    "exclude": ["node_modules", "dist", "custom"],           /* Exclude files from compilation. */
+  }
+  

package/types.ts

@@ -0,0 +1,52 @@
+export type AutoRemoveMode = 'count-based' | 'time-based';
+
+/**
+ * count-based 100, 1k, 1kk, 1m
+ */
+export type HumanNumber = string;
+
+/**
+ * s
+ * min
+ * h
+ * d 
+ * w 
+ * mon
+ * y 
+ */
+export type HumanDuration = string;
+
+export interface PluginOptions {
+  createdAtField: string;
+
+  /**
+   * - count-based: Delete items > maxItems
+   * - time-based: Delete age > maxAge
+   */
+  mode: AutoRemoveMode;
+
+  /**
+   * for count-based mode (100', '1k', '10k', '1m')
+   */
+  keepAtLeast?: HumanNumber;
+
+  /**
+   * Minimum number of items to always keep in count-based mode.
+   * This acts as a safety threshold together with `keepAtLeast`.
+   * Example formats: '100', '1k', '10k', '1m'.
+   * 
+   * Validation ensures that minItemsKeep <= keepAtLeast. 
+  */
+  minItemsKeep?: HumanNumber;
+
+  /**
+   * Max age of item for time-based mode ('1d', '7d', '1mo', '1y')
+   */
+  deleteOlderThan?: HumanDuration;
+
+  /**
+   * Interval for running cleanup (e.g. '1h', '1d')
+   * Default '1d'
+   */
+  interval?: HumanDuration;
+}

package/utils/parseDuration.ts

@@ -0,0 +1,20 @@
+const UNITS: Record<string, number> = {
+  s: 1000,
+  m: 60_000,
+  h: 3_600_000,
+  d: 86_400_000,
+  w: 604_800_000,
+  mo: 2_592_000_000,
+  y: 31_536_000_000,
+};
+
+export function parseDuration(value: string): number {
+  const match = value.match(/^(\d+)\s*(s|m|h|d|w|mo|y)$/);
+  if (!match) {
+    throw new Error(`Invalid duration format: ${value}`);
+  }
+
+  const [, amount, unit] = match;
+  return Number(amount) * UNITS[unit];
+}
+

package/utils/parseNumber.ts

@@ -0,0 +1,9 @@
+export function parseHumanNumber(value: string): number {
+  const v = value.toLowerCase().trim();
+
+  if (v.endsWith('kk')) return Number(v.slice(0, -2)) * 1_000_000;
+  if (v.endsWith('k')) return Number(v.slice(0, -1)) * 1_000;
+  if (v.endsWith('m')) return Number(v.slice(0, -1)) * 1_000_000;
+
+  return Number(v);
+}