@adminforth/i18n 1.10.1 → 2.0.1

package/dist/index.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { AdminForthPlugin, Filters, suggestIfTypo, AdminForthDataTypes, RAMLock } from "adminforth";
+import { AdminForthPlugin, Filters, suggestIfTypo, AdminForthDataTypes, RAMLock, filtersTools, AdminForthFilterOperators } from "adminforth";
 import iso6391 from 'iso-639-1';
 import path from 'path';
 import fs from 'fs-extra';
@@ -15,6 +15,8 @@ import chokidar from 'chokidar';
 import { AsyncQueue } from '@sapphire/async-queue';
 import getFlagEmoji from 'country-flag-svg';
 import { parse } from 'bcp-47';
+import pLimit from 'p-limit';
+import { afLogger } from "adminforth";
 const processFrontendMessagesQueue = new AsyncQueue();
 const SLAVIC_PLURAL_EXAMPLES = {
     uk: 'яблук | Яблуко | Яблука | Яблук', // zero | singular | 2-4 | 5+
@@ -146,6 +148,12 @@ export default class I18nPlugin extends AdminForthPlugin {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             _super.modifyResourceConfig.call(this, adminforth, resourceConfig);
+            if (!this.adminforth.config.componentsToExplicitRegister) {
+                this.adminforth.config.componentsToExplicitRegister = [];
+            }
+            this.adminforth.config.componentsToExplicitRegister.push({
+                file: this.componentPath('TranslationJobViewComponent.vue')
+            });
             // validate each supported language: ISO 639-1 or BCP-47 with region (e.g., en-GB)
             this.options.supportedLanguages.forEach((lang) => {
                 if (!isValidSupportedLanguageTag(lang)) {
@@ -408,10 +416,10 @@ export default class I18nPlugin extends AdminForthPlugin {
             if (!resourceConfig.options.pageInjections.list) {
                 resourceConfig.options.pageInjections.list = {};
             }
-            if (!resourceConfig.options.pageInjections.list.beforeActionButtons) {
-                resourceConfig.options.pageInjections.list.beforeActionButtons = [];
+            if (!resourceConfig.options.pageInjections.list.threeDotsDropdownItems) {
+                resourceConfig.options.pageInjections.list.threeDotsDropdownItems = [];
             }
-            resourceConfig.options.pageInjections.list.beforeActionButtons.push(pageInjection);
+            resourceConfig.options.pageInjections.list.threeDotsDropdownItems.push(pageInjection);
             // if there is menu item with resourceId, add .badge function showing number of untranslated strings
             const addBadgeCountToMenuItem = (menuItem) => {
                 this.menuItemWithBadgeId = menuItem.itemId;
@@ -436,43 +444,9 @@ export default class I18nPlugin extends AdminForthPlugin {
             });
         });
     }
-    translateToLang(langIsoCode_1, strings_1) {
-        return __awaiter(this, arguments, void 0, function* (langIsoCode, strings, plurals = false, translations, updateStrings = {}) {
-            var _a;
-            const maxKeysInOneReq = 10;
-            if (strings.length === 0) {
-                return [];
-            }
-            const replacedLanguageCodeForTranslations = this.options.translateLangAsBCP47Code && langIsoCode.length === 2 ? this.options.translateLangAsBCP47Code[langIsoCode] : null;
-            if (strings.length > maxKeysInOneReq) {
-                let totalTranslated = [];
-                for (let i = 0; i < strings.length; i += maxKeysInOneReq) {
-                    const slicedStrings = strings.slice(i, i + maxKeysInOneReq);
-                    process.env.HEAVY_DEBUG && console.log('🪲🔪slicedStrings len', slicedStrings.length);
-                    const madeKeys = yield this.translateToLang(langIsoCode, slicedStrings, plurals, translations, updateStrings);
-                    totalTranslated = totalTranslated.concat(madeKeys);
-                }
-                return totalTranslated;
-            }
-            const langCode = replacedLanguageCodeForTranslations ? replacedLanguageCodeForTranslations : langIsoCode;
-            const lang = langIsoCode;
-            const primaryLang = getPrimaryLanguageCode(lang);
-            const langName = iso6391.getName(primaryLang);
-            const requestSlavicPlurals = Object.keys(SLAVIC_PLURAL_EXAMPLES).includes(primaryLang) && plurals;
-            const region = ((_a = String(lang).split('-')[1]) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || '';
-            const prompt = `
-        I need to translate strings in JSON to ${langName} language ${replacedLanguageCodeForTranslations || lang.length > 2 ? `BCP-47 code ${langCode}` : `ISO 639-1 code ${langIsoCode}`} from English for my web app.
-        ${region ? `Use the regional conventions for ${langCode} (region ${region}), including spelling, punctuation, and formatting.` : ''}
-        ${requestSlavicPlurals ? `You should provide 4 slavic forms (in format "zero count | singular count | 2-4 | 5+") e.g. "apple | apples" should become "${SLAVIC_PLURAL_EXAMPLES[lang]}"` : ''}
-        Keep keys, as is, write translation into values! If keys have variables (in curly brackets), then translated strings should have them as well (variables itself should not be translated). Here are the strings:
-
-        \`\`\`json
-        ${JSON.stringify(strings.reduce((acc, s) => {
-                acc[s.en_string] = '';
-                return acc;
-            }, {}), null, 2)}
-    \`\`\`
-    `;
+    generateAndSaveBunch(prompt_1, strings_1, translations_1) {
+        return __awaiter(this, arguments, void 0, function* (prompt, strings, translations, updateStrings = {}, lang, failedToTranslate, needToTranslateByLang = {}, jobId, promptCost) {
+            // return [];
             const jsonSchemaProperties = {};
             strings.forEach(s => {
                 jsonSchemaProperties[s.en_string] = {
@@ -481,6 +455,7 @@ export default class I18nPlugin extends AdminForthPlugin {
                 };
             });
             const jsonSchemaRequired = strings.map(s => s.en_string);
+            const dedupRequired = Array.from(new Set(jsonSchemaRequired));
             // call OpenAI
             const resp = yield this.options.completeAdapter.complete(prompt, [], prompt.length * 2, {
                 json_schema: {
@@ -488,7 +463,7 @@ export default class I18nPlugin extends AdminForthPlugin {
                     schema: {
                         type: "object",
                         properties: jsonSchemaProperties,
-                        required: jsonSchemaRequired,
+                        required: dedupRequired,
                     },
                 },
             });
@@ -496,32 +471,48 @@ export default class I18nPlugin extends AdminForthPlugin {
             if (resp.error) {
                 throw new AiTranslateError(resp.error);
             }
-            // parse response like
-            // Here are the translations for the strings you provided:
-            // ```json
-            // [{"live": "canlı"}, {"Table Games": "Masa Oyunları"}]
-            // ```
             let res;
             try {
-                res = resp.content; //.split("```json")[1].split("```")[0];
+                res = resp.content;
             }
             catch (e) {
                 console.error(`Error in parsing LLM resp: ${resp}\n Prompt was: ${prompt}\n Resp was: ${JSON.stringify(resp)}`);
-                return [];
+                strings.forEach(s => {
+                    failedToTranslate.push({
+                        lang: lang,
+                        en_string: s.en_string,
+                        failedReason: "Error in parsing LLM response"
+                    });
+                });
+                return null;
             }
+            const backgroundJobsPlugin = this.adminforth.getPluginByClassName('BackgroundJobsPlugin');
+            backgroundJobsPlugin.updateJobFieldsAtomically(jobId, () => __awaiter(this, void 0, void 0, function* () {
+                // do all set / get fields in this function to make state update atomic and there is no conflicts when 2 tasks in parallel do get before set.
+                // don't do long awaits in this callback, since it has exclusive lock.
+                let totalUsedTokens = yield backgroundJobsPlugin.getJobField(jobId, 'totalUsedTokens');
+                totalUsedTokens += promptCost;
+                yield backgroundJobsPlugin.setJobField(jobId, 'totalUsedTokens', totalUsedTokens);
+            }));
             try {
                 res = JSON.parse(res);
             }
             catch (e) {
                 console.error(`Error in parsing LLM resp json: ${resp}\n Prompt was: ${prompt}\n Resp was: ${JSON.stringify(resp)}`);
-                return [];
+                strings.forEach(s => {
+                    failedToTranslate.push({
+                        lang: lang,
+                        en_string: s.en_string,
+                        failedReason: "Error in parsing LLM response JSON"
+                    });
+                });
+                return null;
             }
             for (const [enStr, translatedStr] of Object.entries(res)) {
                 const translationsTargeted = translations.filter(t => t[this.enFieldName] === enStr);
                 // might be several with same en_string
                 for (const translation of translationsTargeted) {
                     //translation[this.trFieldNames[lang]] = translatedStr;
-                    // process.env.HEAVY_DEBUG && console.log(`🪲translated to ${lang} ${translation.en_string}, ${translatedStr}`)
                     if (!updateStrings[translation[this.primaryKeyFieldName]]) {
                         updateStrings[translation[this.primaryKeyFieldName]] = {
                             updates: {},
@@ -539,12 +530,134 @@ export default class I18nPlugin extends AdminForthPlugin {
                     updateStrings[translation[this.primaryKeyFieldName]].updates[this.trFieldNames[lang]] = translatedStr;
                 }
             }
-            return Object.keys(updateStrings);
+            const langsInvolved = new Set(Object.keys(needToTranslateByLang));
+            // here we need to save updateStrings
+            yield Promise.all(Object.entries(updateStrings).map((_a) => __awaiter(this, [_a], void 0, function* ([_, { updates, strId }]) {
+                // get old full record
+                const oldRecord = yield this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(this.primaryKeyFieldName, strId)]);
+                // because this will translate all languages, we can set completedLangs to all languages
+                const futureCompletedFieldValue = yield this.computeCompletedFieldValue(Object.assign(Object.assign({}, oldRecord), updates));
+                yield this.adminforth.resource(this.resourceConfig.resourceId).update(strId, Object.assign(Object.assign({}, updates), { [this.options.completedFieldName]: futureCompletedFieldValue }));
+            })));
+            for (const lang of langsInvolved) {
+                const categoriesInvolved = new Set();
+                for (const { enStr, category } of Object.values(updateStrings)) {
+                    categoriesInvolved.add(category);
+                    yield this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}:${enStr}`);
+                }
+                for (const category of categoriesInvolved) {
+                    yield this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}`);
+                }
+            }
+        });
+    }
+    getTranslateToLangTasks(langIsoCode_1, strings_1) {
+        return __awaiter(this, arguments, void 0, function* (langIsoCode, strings, plurals = false, translations, updateStrings = {}, needToTranslateByLang = {}, adminUser) {
+            var _a, _b;
+            const maxInputTokens = (_a = this.options.inputTokensPerBatch) !== null && _a !== void 0 ? _a : 30000;
+            const limit = pLimit(30);
+            const enStringsTokenLengthCache = {};
+            const tokenLengthPerString = (_a) => __awaiter(this, [_a], void 0, function* ({ str, id }) {
+                const objectToPush = {
+                    en_string: str,
+                    numOfTokens: yield this.options.completeAdapter.measureTokensCount(`"${str}":"", \n`)
+                };
+                enStringsTokenLengthCache[id] = objectToPush;
+            });
+            const promises = strings.map(s => limit(() => tokenLengthPerString({ str: s.en_string, id: s.id })));
+            yield Promise.all(promises);
+            if (strings.length === 0) {
+                return;
+            }
+            const replacedLanguageCodeForTranslations = this.options.translateLangAsBCP47Code && langIsoCode.length === 2 ? this.options.translateLangAsBCP47Code[langIsoCode] : null;
+            const langSchema = parse(String(langIsoCode), {
+                normalize: true,
+            });
+            const langCode = replacedLanguageCodeForTranslations ? replacedLanguageCodeForTranslations : langIsoCode;
+            const lang = langIsoCode;
+            const primaryLang = getPrimaryLanguageCode(lang);
+            const langName = iso6391.getName(primaryLang);
+            const requestSlavicPlurals = Object.keys(SLAVIC_PLURAL_EXAMPLES).includes(primaryLang) && plurals;
+            const region = langSchema.region;
+            const basePrompt = `
+      I need to translate strings in JSON to ${langName} language ${replacedLanguageCodeForTranslations || lang.length > 2 ? `BCP-47 code ${langCode}` : `ISO 639-1 code ${langIsoCode}`} from English for my web app.
+
+      
+      ${region ? `Use the regional conventions for ${langCode} (region ${region}), including spelling, punctuation, and formatting.` : ''}
+      ${requestSlavicPlurals ? `You should provide 4 slavic forms (in format "zero count | singular count | 2-4 | 5+") e.g. "apple | apples" should become "${SLAVIC_PLURAL_EXAMPLES[lang]}"` : ''}
+      Keep keys, as is, write translation into values! If keys have variables (in curly brackets), then translated strings should have them as well (variables itself should not be translated). Here are the strings:
+      \`\`\`json
+      {
+
+      }
+      \`\`\`
+    `;
+            const failedToTranslate = [];
+            const basePromptTokenLength = yield this.options.completeAdapter.measureTokensCount(basePrompt);
+            const allowedTokensAmountForFields = maxInputTokens - basePromptTokenLength;
+            const stringsToTranslate = Object.fromEntries(strings.map(s => [s.id, s]));
+            const generationTasksInitialData = [];
+            while (Object.keys(stringsToTranslate).length !== 0) {
+                const stringBanch = [];
+                const stringIdsInBatch = [];
+                let banchTokens = 0;
+                for (const id of Object.keys(stringsToTranslate)) {
+                    const { en_string } = stringsToTranslate[id];
+                    const numberOfTokensForString = ((_b = enStringsTokenLengthCache[id]) === null || _b === void 0 ? void 0 : _b.numOfTokens) || 0;
+                    if (banchTokens + numberOfTokensForString <= allowedTokensAmountForFields) {
+                        stringBanch.push(en_string);
+                        stringIdsInBatch.push(id);
+                        banchTokens += numberOfTokensForString;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                if (stringBanch.length === 0) {
+                    Object.values(stringsToTranslate).forEach(s => {
+                        failedToTranslate.push({
+                            lang,
+                            en_string: s.en_string,
+                            failedReason: "Not enough input generation tokens"
+                        });
+                        generationTasksInitialData.push({
+                            state: {
+                                failedToTranslate,
+                            }
+                        });
+                    });
+                    break;
+                }
+                for (const id of stringIdsInBatch) {
+                    delete stringsToTranslate[id];
+                }
+                const promptToGenerate = basePrompt.split(`\`\`\`json`)[0] +
+                    `\`\`\`json
+        {
+          ${stringBanch.map(s => `"${s}": ""`).join(",\n")}
+        }
+        \`\`\``;
+                const stringBanchCopy = [...stringBanch];
+                generationTasksInitialData.push({
+                    state: {
+                        taskName: `Translate ${strings.length} strings`,
+                        prompt: promptToGenerate,
+                        strings: strings.filter(s => stringBanchCopy.includes(s.en_string)),
+                        translations: translations.filter(t => stringBanchCopy.includes(t.en_string)),
+                        updateStrings,
+                        lang,
+                        failedToTranslate,
+                        needToTranslateByLang,
+                        promptCost: basePromptTokenLength + banchTokens,
+                    }
+                });
+            }
+            return generationTasksInitialData;
         });
     }
     // returns translated count
     bulkTranslate(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ selectedIds, selectedLanguages }) {
+        return __awaiter(this, arguments, void 0, function* ({ selectedIds, selectedLanguages, adminUser }) {
             const needToTranslateByLang = {};
             const translations = yield this.adminforth.resource(this.resourceConfig.resourceId).list(Filters.IN(this.primaryKeyFieldName, selectedIds));
             const languagesToProcess = selectedLanguages || this.options.supportedLanguages;
@@ -559,6 +672,7 @@ export default class I18nPlugin extends AdminForthPlugin {
                             needToTranslateByLang[lang] = [];
                         }
                         needToTranslateByLang[lang].push({
+                            id: translation[this.primaryKeyFieldName],
                             'en_string': translation[this.enFieldName],
                             category: translation[this.options.categoryFieldName],
                         });
@@ -566,34 +680,25 @@ export default class I18nPlugin extends AdminForthPlugin {
                 }
             }
             const updateStrings = {};
-            const langsInvolved = new Set(Object.keys(needToTranslateByLang));
-            let totalTranslated = [];
+            let generationTasksInitialData = [];
             yield Promise.all(Object.entries(needToTranslateByLang).map((_a) => __awaiter(this, [_a], void 0, function* ([lang, strings]) {
                 // first translate without plurals
                 const stringsWithoutPlurals = strings.filter(s => !s.en_string.includes('|'));
-                const noPluralKeys = yield this.translateToLang(lang, stringsWithoutPlurals, false, translations, updateStrings);
+                const noPluralTranslationsTasks = yield this.getTranslateToLangTasks(lang, stringsWithoutPlurals, false, translations, updateStrings, needToTranslateByLang, adminUser);
                 const stringsWithPlurals = strings.filter(s => s.en_string.includes('|'));
-                const pluralKeys = yield this.translateToLang(lang, stringsWithPlurals, true, translations, updateStrings);
-                totalTranslated = totalTranslated.concat(noPluralKeys, pluralKeys);
-            })));
-            yield Promise.all(Object.entries(updateStrings).map((_a) => __awaiter(this, [_a], void 0, function* ([_, { updates, strId }]) {
-                // get old full record
-                const oldRecord = yield this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(this.primaryKeyFieldName, strId)]);
-                // because this will translate all languages, we can set completedLangs to all languages
-                const futureCompletedFieldValue = yield this.computeCompletedFieldValue(Object.assign(Object.assign({}, oldRecord), updates));
-                yield this.adminforth.resource(this.resourceConfig.resourceId).update(strId, Object.assign(Object.assign({}, updates), { [this.options.completedFieldName]: futureCompletedFieldValue }));
+                const pluralTranslationsTasks = yield this.getTranslateToLangTasks(lang, stringsWithPlurals, true, translations, updateStrings, needToTranslateByLang, adminUser);
+                generationTasksInitialData = generationTasksInitialData.concat(noPluralTranslationsTasks || []).concat(pluralTranslationsTasks || []);
             })));
-            for (const lang of langsInvolved) {
-                const categoriesInvolved = new Set();
-                for (const { enStr, category } of Object.values(updateStrings)) {
-                    categoriesInvolved.add(category);
-                    yield this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}:${enStr}`);
-                }
-                for (const category of categoriesInvolved) {
-                    yield this.cache.clear(`${this.resourceConfig.resourceId}:${category}:${lang}`);
-                }
-            }
-            return new Set(totalTranslated).size;
+            const totalTranslationTokenCost = generationTasksInitialData.reduce((a, b) => { var _a; return a + (((_a = b.state) === null || _a === void 0 ? void 0 : _a.promptCost) || 0); }, 0);
+            const backgroundJobsPlugin = this.adminforth.getPluginByClassName('BackgroundJobsPlugin');
+            const jobId = yield backgroundJobsPlugin.startNewJob(`Translate ${selectedIds.length} items`, //job name
+            adminUser, // adminuser
+            generationTasksInitialData, //initial tasks
+            'translation_job_handler');
+            afLogger.info(`Started background job with ID ${jobId} `);
+            yield backgroundJobsPlugin.setJobField(jobId, 'totalTranslationTokenCost', totalTranslationTokenCost);
+            yield backgroundJobsPlugin.setJobField(jobId, 'totalUsedTokens', 0);
+            return jobId;
         });
     }
     processExtractedMessages(adminforth, filePath) {
@@ -645,6 +750,41 @@ export default class I18nPlugin extends AdminForthPlugin {
     validateConfigAfterDiscover(adminforth, resourceConfig) {
         // optional method where you can safely check field types after database discovery was performed
         // ensure each trFieldName (apart from enFieldName) is nullable column of type string
+        const backgroundJobsPlugin = adminforth.getPluginByClassName('BackgroundJobsPlugin');
+        if (!backgroundJobsPlugin) {
+            throw new Error(`BackgroundJobsPlugin is required for ${this.constructor.name} to work, please add it to your plugins`);
+        }
+        backgroundJobsPlugin.registerTaskHandler({
+            // job handler name
+            jobHandlerName: 'translation_job_handler',
+            //handler function
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ jobId, setTaskStateField, getTaskStateField }) {
+                const initialState = yield getTaskStateField();
+                if (initialState.prompt && initialState.strings && initialState.translations && initialState.updateStrings && initialState.lang && initialState.failedToTranslate && initialState.needToTranslateByLang) {
+                    yield this.generateAndSaveBunch(initialState.prompt, initialState.strings, initialState.translations, initialState.updateStrings, initialState.lang, initialState.failedToTranslate, initialState.needToTranslateByLang, jobId, initialState.promptCost);
+                }
+                afLogger.debug(`Translation task for language ${initialState.lang} completed.`);
+                const stateToSave = {
+                    taskName: initialState.taskName,
+                    lang: initialState.lang,
+                    failedToTranslate: initialState.failedToTranslate,
+                };
+                yield setTaskStateField(stateToSave);
+                this.adminforth.websocket.publish('/translation_progress', {});
+                if (initialState.failedToTranslate.length > 0) {
+                    afLogger.error(`Failed to translate some strings for language ${initialState.lang} in plugin ${this.constructor.name}:, ${initialState.failedToTranslate}`);
+                    throw new Error(`Failed to translate some strings for language ${initialState.lang}, check job details for more info`);
+                }
+            }),
+            //limit of tasks, that are running in parallel
+            parallelLimit: this.options.parallelTranslationLimit || 20,
+        });
+        backgroundJobsPlugin.registerTaskDetailsComponent({
+            jobHandlerName: 'translation_job_handler', // Handler name
+            component: {
+                file: this.componentPath('TranslationJobViewComponent.vue') //custom component for the job details
+            },
+        });
         if (this.options.completeAdapter) {
             this.options.completeAdapter.validate();
         }
@@ -905,29 +1045,75 @@ export default class I18nPlugin extends AdminForthPlugin {
             method: 'POST',
             path: `/plugin/${this.pluginInstanceId}/translate-selected-to-languages`,
             noAuth: false,
-            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, tr }) {
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, tr, adminUser }) {
                 const selectedLanguages = body.selectedLanguages;
                 const selectedIds = body.selectedIds;
-                let translatedCount = 0;
-                try {
-                    translatedCount = yield this.bulkTranslate({ selectedIds, selectedLanguages });
-                }
-                catch (e) {
-                    process.env.HEAVY_DEBUG && console.error('🪲⛔ bulkTranslate error', e);
-                    if (e instanceof AiTranslateError) {
-                        return { ok: false, error: e.message };
-                    }
-                    throw e;
-                }
-                this.updateUntranslatedMenuBadge();
+                const jobId = yield this.bulkTranslate({ selectedIds, selectedLanguages, adminUser });
                 return {
                     ok: true,
-                    error: undefined,
-                    successMessage: yield tr(`Translated {count} items`, 'backend', {
-                        count: translatedCount,
-                    }),
+                    jobId: jobId,
                 };
             })
         });
+        server.endpoint({
+            method: 'POST',
+            path: `/plugin/${this.pluginInstanceId}/get_filtered_ids`,
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, headers, query, cookies, requestUrl }) {
+                var _b, _c;
+                const resource = this.resourceConfig;
+                for (const hook of ((_c = (_b = resource.hooks) === null || _b === void 0 ? void 0 : _b.list) === null || _c === void 0 ? void 0 : _c.beforeDatasourceRequest) || []) {
+                    const filterTools = filtersTools.get(body);
+                    body.filtersTools = filterTools;
+                    const resp = yield hook({
+                        resource,
+                        query: body,
+                        adminUser,
+                        //@ts-ignore
+                        filtersTools: filterTools,
+                        extra: {
+                            body, query, headers, cookies, requestUrl
+                        },
+                        adminforth: this.adminforth,
+                    });
+                    if (!resp || (!resp.ok && !resp.error)) {
+                        throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
+                    }
+                    if (resp.error) {
+                        return { error: resp.error };
+                    }
+                }
+                const filters = body.filters;
+                const normalizedFilters = { operator: AdminForthFilterOperators.AND, subFilters: [] };
+                if (filters) {
+                    if (typeof filters !== 'object') {
+                        throw new Error(`Filter should be an array or an object`);
+                    }
+                    if (Array.isArray(filters)) {
+                        // if filters are an array, they will be connected with "AND" operator by default
+                        normalizedFilters.subFilters = filters;
+                    }
+                    else if (filters.field) {
+                        // assume filter is a SingleFilter
+                        normalizedFilters.subFilters = [filters];
+                    }
+                    else if (filters.subFilters) {
+                        // assume filter is a AndOr filter
+                        normalizedFilters.operator = filters.operator;
+                        normalizedFilters.subFilters = filters.subFilters;
+                    }
+                    else {
+                        // wrong filter
+                        throw new Error(`Wrong filter object value: ${JSON.stringify(filters)}`);
+                    }
+                }
+                const records = yield this.adminforth.resource(this.resourceConfig.resourceId).list(normalizedFilters);
+                if (!records) {
+                    return { ok: true, recordIds: [] };
+                }
+                const primaryKeyColumn = this.resourceConfig.columns.find((col) => col.primaryKey);
+                const recordIds = records.map(record => record[primaryKeyColumn.name]);
+                return { ok: true, recordIds };
+            })
+        });
     }
 }