@apify/input_schema 2.1.0 → 3.1.0

package/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/intl.ts","../src/input_schema.ts","../src/utilities.ts"],"sourcesContent":["/* eslint-disable max-len,quotes,quote-props */\nconst intlStrings = {\n    'inputSchema.validation.generic':\n        'Field {rootName}.{fieldKey} {message}',\n    'inputSchema.validation.required':\n        'Field {rootName}.{fieldKey} is required',\n    'inputSchema.validation.proxyRequired':\n        'Field {rootName}.{fieldKey} is required. Please provide custom proxy URLs or use Apify Proxy.',\n    'inputSchema.validation.requestListSourcesInvalid':\n        'Items in {rootName}.{fieldKey} at positions [{invalidIndexes}] do not contain valid URLs',\n    'inputSchema.validation.arrayKeysInvalid':\n        'Keys in {rootName}.{fieldKey} at positions [{invalidIndexes}] must match regular expression \"{pattern}\"',\n    'inputSchema.validation.arrayValuesInvalid':\n        'Values in {rootName}.{fieldKey} at positions [{invalidIndexes}] must match regular expression \"{pattern}\"',\n    'inputSchema.validation.objectKeysInvalid':\n        'Keys [{invalidKeys}] in {rootName}.{fieldKey} must match regular expression \"{pattern}',\n    'inputSchema.validation.objectValuesInvalid':\n        'Keys [{invalidKeys}] in {rootName}.{fieldKey} must have string value which matches regular expression \"{pattern}\"',\n    'inputSchema.validation.additionalProperty':\n        'Property {rootName}.{fieldKey} is not allowed.',\n    'inputSchema.validation.proxyGroupsNotAvailable':\n        'You currently do not have access to proxy groups: {groups}',\n    'inputSchema.validation.customProxyInvalid':\n        'Proxy URL \"{invalidUrl}\" has invalid format, it must be http://[username[:password]]@hostname:port.',\n    'inputSchema.validation.apifyProxyCountryInvalid':\n        'Country code \"{invalidCountry}\" is invalid. Only ISO 3166-1 alpha-2 country codes are supported.',\n    'inputSchema.validation.apifyProxyCountryWithoutApifyProxyForbidden':\n        'The country for Apify Proxy can be specified only when using Apify Proxy.',\n    'inputSchema.validation.noAvailableAutoProxy':\n        'Currently you do not have access to any proxy group usable in automatic mode.',\n    'inputSchema.validation.noMatchingDefinition':\n        'Field schema.properties.{fieldKey} is not matching any input schema type definition. Please make sure that it\\'s type is valid.',\n};\n/* eslint-enable max-len,quotes,quote-props */\n\n/**\n * Helper function to simulate intl formatMessage function\n */\nexport function m(stringId: string, variables?: Record<string, any>) {\n    let text = intlStrings[stringId];\n    if (!text) return stringId;\n\n    if (variables) {\n        Object.keys(variables).forEach((variableName) => {\n            text = text.split(`{${variableName}}`).join(variables[variableName]);\n        });\n    }\n\n    return text;\n}\n","import Ajv, { ErrorObject } from 'ajv';\nimport schema from './schema.json';\nimport { m } from './intl';\n\nexport { schema as inputSchema };\nconst { definitions } = schema;\n\n/**\n * This function parses AJV error and transforms it into a readable string.\n *\n * @param error An error as returned from AJV.\n * @param rootName Usually 'input' or 'schema' based on if we are passing the input or schema.\n * @param properties (Used only when parsing input errors) List of input schema properties.\n * @param input (Used only when parsing input errors) Actual input that is being parsed.\n * @returns {null|{fieldKey: *, message: *}}\n */\nexport function parseAjvError(\n    error: ErrorObject,\n    rootName: string,\n    properties: Record<string, { nullable?: boolean }> = {},\n    input: Record<string, unknown> = {},\n): { fieldKey: string; message: string } | null {\n    // There are 3 possible errors comming from validation:\n    // - either { keword: 'anything', instancePath: '/someField', message: 'error message that we can use' }\n    // - or { keyword: 'additionalProperties', params: { additionalProperty: 'field' }, message: 'must NOT have additional properties' }\n    // - or { keyword: 'required', instancePath: '', params.missingProperty: 'someField' }\n\n    let fieldKey: string;\n    let message: string;\n\n    // If error is with keyword type, it means that type of input is incorrect\n    // this can mean that provided value is null\n    if (error.keyword === 'type') {\n        fieldKey = error.instancePath.split('/').pop()!;\n        // Check if value is null and field is nullable, if yes, then skip this error\n        if (properties[fieldKey] && properties[fieldKey].nullable && input[fieldKey] === null) {\n            return null;\n        }\n        message = m('inputSchema.validation.generic', { rootName, fieldKey, message: error.message });\n    } else if (error.keyword === 'required') {\n        fieldKey = error.params.missingProperty;\n        message = m('inputSchema.validation.required', { rootName, fieldKey });\n    } else if (error.keyword === 'additionalProperties') {\n        fieldKey = error.params.additionalProperty;\n        message = m('inputSchema.validation.additionalProperty', { rootName, fieldKey });\n    } else if (error.keyword === 'enum') {\n        fieldKey = error.instancePath.split('/').pop()!;\n        const errorMessage = `${error.message}: \"${error.params.allowedValues.join('\", \"')}\"`;\n        message = m('inputSchema.validation.generic', { rootName, fieldKey, message: errorMessage });\n    } else {\n        fieldKey = error.instancePath.split('/').pop()!;\n        message = m('inputSchema.validation.generic', { rootName, fieldKey, message: error.message });\n    }\n\n    return { fieldKey, message };\n}\n\n/**\n * Validates given object against schema and throws a human readable error.\n */\nconst validateAgainstSchemaOrThrow = <T> (validator: Ajv, obj: T, inputSchema: any, rootName: string) => {\n    if (validator.validate(inputSchema, obj)) return;\n\n    const errorMessage = parseAjvError(validator.errors![0], rootName)?.message;\n    throw new Error(`Input schema is not valid (${errorMessage})`);\n};\n\n/**\n * This validates given object only against the basic input schema without checking the particular fields.\n * We override schema.properties.properties not to validate field defitions.\n */\nconst validateBasicStructure = <T> (validator: Ajv, obj: T) => {\n    const schemaWithoutProperties = { ...schema };\n    schemaWithoutProperties.properties = { ...schema.properties, properties: { type: 'object' } as any };\n    validateAgainstSchemaOrThrow(validator, obj, schemaWithoutProperties, 'schema');\n};\n\n/**\n * Validates particular field against it's schema.\n */\nconst validateField = <T extends Record<string, any>> (validator: Ajv, fieldSchema: T, fieldKey: string) => {\n    const matchingDefinitions = Object\n        .values<any>(definitions) // cast as any, as the code in first branch seems to be invalid\n        .filter((definition) => {\n            return definition.properties.type.enum\n                // This is a normal case where fieldSchema.type can be only one possible value matching definition.properties.type.enum.0\n                ? definition.properties.type.enum[0] === fieldSchema.type\n                // This is a type \"Any\" where fieldSchema.type is an array of possible values\n                : Array.isArray(fieldSchema.type);\n        });\n\n    // There is not matching definition.\n    if (matchingDefinitions.length === 0) {\n        const errorMessage = m('inputSchema.validation.noMatchingDefinition', { fieldKey });\n        throw new Error(`Input schema is not valid (${errorMessage})`);\n    }\n\n    // If there is only one matching then we are done and simply compare it.\n    if (matchingDefinitions.length === 1) {\n        validateAgainstSchemaOrThrow(validator, fieldSchema, matchingDefinitions[0], `schema.properties.${fieldKey}`);\n        return;\n    }\n\n    // If there are more matching definitions then the type is string and we need to get the right one.\n    // If the definition contains \"enum\" property then it's enum type.\n    if (fieldSchema.enum) {\n        const definition = matchingDefinitions.filter((item) => !!item.properties.enum).pop();\n        if (!definition) throw new Error('Input schema validation failed to find \"enum property\" definition');\n        validateAgainstSchemaOrThrow(validator, fieldSchema, definition, `schema.properties.${fieldKey}.enum`);\n        return;\n    }\n    // Otherwise we use the other definition.\n    const definition = matchingDefinitions.filter((item) => !item.properties.enum).pop();\n    if (!definition) throw new Error('Input schema validation failed to find other than \"enum property\" definition');\n\n    validateAgainstSchemaOrThrow(validator, fieldSchema, definition, `schema.properties.${fieldKey}`);\n};\n\n/**\n * This function validates given input schema first just for basic structure then each field one by one and\n * finally fully against the whole schema.\n *\n * This way we get the most accurate error message for user.\n */\nexport function validateInputSchema<T extends Record<string, any>>(validator: Ajv, inputSchema: T) {\n    // First validate just basic structure without fields.\n    validateBasicStructure(validator, inputSchema);\n\n    // Then validate each field separately.\n    Object.entries<any>(inputSchema.properties).forEach(([fieldKey, fieldSchema]) => validateField(validator, fieldSchema, fieldKey));\n\n    // Finally just to be sure run validation against the whole shema.\n    validateAgainstSchemaOrThrow(validator, inputSchema, schema, 'schema');\n}\n","import { PROXY_URL_REGEX, URL_REGEX } from '@apify/consts';\nimport { countries } from 'countries-list';\nimport { ValidateFunction } from 'ajv';\nimport { parseScript } from 'escaya';\nimport { m } from './intl';\nimport { parseAjvError } from './input_schema';\n\n/**\n * Validates input field configured with proxy editor\n * @param fieldKey Proxy field value\n * @param value Proxy field value\n * @param [isRequired] Whether the field is required or not\n * @param [options] Information about proxy groups availability\n * @param [options.hasAutoProxyGroups] Informs validation whether user has atleast one proxy group available in auto mode\n * @param [options.availableProxyGroups] List of available proxy groups\n * @param [options.disabledProxyGroups] Object with groupId as key and error message as value (mostly for residential/SERP)\n */\nfunction validateProxyField(\n    fieldKey: Record<string, unknown>,\n    value: Record<string, any>,\n    isRequired = false,\n    options: { hasAutoProxyGroups?: boolean; availableProxyGroups?: string[]; disabledProxyGroups?: Record<string, unknown> } | null = null,\n) {\n    const fieldErrors: any[] = [];\n    if (isRequired) {\n        // Nullable error is already handled by AJV\n        if (value === null) return fieldErrors;\n        if (!value) {\n            const message = m('inputSchema.validation.required', { rootName: 'input', fieldKey });\n            fieldErrors.push(message);\n            return fieldErrors;\n        }\n\n        const { useApifyProxy, proxyUrls } = value;\n        if (!useApifyProxy && (!Array.isArray(proxyUrls) || proxyUrls.length === 0)) {\n            fieldErrors.push(m('inputSchema.validation.proxyRequired', { rootName: 'input', fieldKey }));\n            return fieldErrors;\n        }\n    }\n\n    // Input is not required, so missing value is valid\n    if (!value) return fieldErrors;\n\n    const { useApifyProxy, proxyUrls, apifyProxyGroups, apifyProxyCountry } = value;\n\n    if (!useApifyProxy && Array.isArray(proxyUrls)) {\n        let invalidUrl = false;\n        proxyUrls.forEach((url) => {\n            if (!PROXY_URL_REGEX.test(url.trim())) invalidUrl = url.trim();\n        });\n        if (invalidUrl) {\n            fieldErrors.push(m('inputSchema.validation.customProxyInvalid', { invalidUrl }));\n        }\n    }\n\n    // Apify proxy country can be set only when using Apify proxy\n    if (!useApifyProxy && apifyProxyCountry) {\n        fieldErrors.push(m('inputSchema.validation.apifyProxyCountryWithoutApifyProxyForbidden'));\n    }\n\n    // If Apify proxy is not used skip additional checks\n    if (!useApifyProxy) return fieldErrors;\n\n    // If Apify proxy is used, check if there is a selected country and if so, check that it's valid (empty or a valid country code)\n    if (apifyProxyCountry && !countries[apifyProxyCountry]) {\n        fieldErrors.push(m('inputSchema.validation.apifyProxyCountryInvalid', { invalidCountry: apifyProxyCountry }));\n    }\n\n    // If options are not provided skip additional checks\n    if (!options) return fieldErrors;\n\n    const selectedProxyGroups = (apifyProxyGroups || []);\n\n    // Auto mode, check that user has access to alteast one proxy group usable in this mode\n    if (!selectedProxyGroups.length && !options.hasAutoProxyGroups) {\n        fieldErrors.push(m('inputSchema.validation.noAvailableAutoProxy'));\n        return fieldErrors;\n    }\n\n    // Check if proxy groups selected by user are available to him\n    const availableProxyGroupsById = {};\n    (options.availableProxyGroups || []).forEach((group) => { availableProxyGroupsById[group] = true; });\n    const unavailableProxyGroups = selectedProxyGroups.filter((group: string) => !availableProxyGroupsById[group]);\n\n    if (unavailableProxyGroups.length) {\n        fieldErrors.push(m('inputSchema.validation.proxyGroupsNotAvailable', {\n            rootName: 'input',\n            fieldKey,\n            groups: unavailableProxyGroups.join(', '),\n        }));\n    }\n\n    // Check if any of the proxy groups are blocked and if yes then output the associated message\n    const blockedProxyGroupsById = options.disabledProxyGroups || {};\n    selectedProxyGroups\n        .filter((group: string) => blockedProxyGroupsById[group])\n        .forEach((blockedGroup: string) => {\n            fieldErrors.push(blockedProxyGroupsById[blockedGroup]);\n        });\n\n    return fieldErrors;\n}\n\n/**\n * Uses AJV validator to validate input with input schema and then\n * does custom validation for our own properties (nullable, patternKey, patternValue)\n * @param validator Initialized AJV validator\n * @param inputSchema Valid input schema in object\n * @param input Input object to be validated\n * @param options (Optional) Additional validation configuration for certain fields\n */\nexport function validateInputUsingValidator(\n    validator: ValidateFunction,\n    inputSchema: Record<string, any>,\n    input: Record<string, unknown>,\n    options: Record<string, any> = {},\n) {\n    const isValid = validator(input); // Check if input is valid based on schema values\n\n    const { properties } = inputSchema;\n    const required = inputSchema.required || [];\n\n    let errors: { fieldKey: string, message: string }[] = [];\n    // Process AJV validation errors\n    if (!isValid) {\n        errors = validator.errors!\n            .map((error) => parseAjvError(error, 'input', properties, input))\n            .filter((error) => !!error) as any[];\n    }\n\n    Object.keys(properties).forEach((property) => {\n        const value = input[property] as Record<string, any>;\n        const { type, editor, patternKey, patternValue } = properties[property];\n        const fieldErrors = [];\n        // Check that proxy is required, if yes, valides that it's correctly setup\n        if (type === 'object' && editor === 'proxy') {\n            const proxyValidationErrors = validateProxyField(property as any, value, required.includes(property), options.proxy);\n            proxyValidationErrors.forEach((error) => {\n                fieldErrors.push(error);\n            });\n        }\n        // Check that array items fit patternKey and patternValue\n        if (type === 'array' && value && Array.isArray(value)) {\n            if (editor === 'requestListSources') {\n                const invalidIndexes: any[] = [];\n                value.forEach((item, index) => {\n                    if (!item) invalidIndexes.push(index);\n                    else if (!item.url && !item.requestsFromUrl) invalidIndexes.push(index);\n                    else if (item.url && !URL_REGEX.test(item.url)) invalidIndexes.push(index);\n                    else if (item.requestsFromUrl && !URL_REGEX.test(item.requestsFromUrl)) invalidIndexes.push(index);\n                });\n                if (invalidIndexes.length) {\n                    fieldErrors.push(m('inputSchema.validation.requestListSourcesInvalid', {\n                        rootName: 'input',\n                        fieldKey: property,\n                        invalidIndexes: invalidIndexes.join(','),\n                    }));\n                }\n            }\n            // If patternKey is provided, then validate keys of objects in array\n            if (patternKey && editor === 'keyValue') {\n                const check = new RegExp(patternKey);\n                const invalidIndexes: any[] = [];\n                value.forEach((item, index) => {\n                    if (!check.test(item.key)) invalidIndexes.push(index);\n                });\n                if (invalidIndexes.length) {\n                    fieldErrors.push(m('inputSchema.validation.arrayKeysInvalid', {\n                        rootName: 'input',\n                        fieldKey: property,\n                        invalidIndexes: invalidIndexes.join(','),\n                        pattern: patternKey,\n                    }));\n                }\n            }\n            // If patternValue is provided and editor is keyValue, then validate values of objecs in array\n            if (patternValue && editor === 'keyValue') {\n                const check = new RegExp(patternValue);\n                const invalidIndexes: any[] = [];\n                value.forEach((item, index) => {\n                    if (!check.test(item.value)) invalidIndexes.push(index);\n                });\n                if (invalidIndexes.length) {\n                    fieldErrors.push(m('inputSchema.validation.arrayValuesInvalid', {\n                        rootName: 'input',\n                        fieldKey: property,\n                        invalidIndexes: invalidIndexes.join(','),\n                        pattern: patternValue,\n                    }));\n                }\n            // If patternValue is provided and editor is stringList, then validate each item in array\n            } else if (patternValue && editor === 'stringList') {\n                const check = new RegExp(patternValue);\n                const invalidIndexes: any[] = [];\n                value.forEach((item, index) => {\n                    if (!check.test(item)) invalidIndexes.push(index);\n                });\n                if (invalidIndexes.length) {\n                    fieldErrors.push(m('inputSchema.validation.arrayValuesInvalid', {\n                        rootName: 'input',\n                        fieldKey: property,\n                        invalidIndexes: invalidIndexes.join(','),\n                        pattern: patternValue,\n                    }));\n                }\n            }\n        }\n        // Check that object items fit patternKey and patternValue\n        if (type === 'object' && value) {\n            if (patternKey) {\n                const check = new RegExp(patternKey);\n                const invalidKeys: any[] = [];\n                Object.keys(value).forEach((key) => {\n                    if (!check.test(key)) invalidKeys.push(key);\n                });\n                if (invalidKeys.length) {\n                    fieldErrors.push(m('inputSchema.validation.objectKeysInvalid', {\n                        rootName: 'input',\n                        fieldKey: property,\n                        invalidKeys: invalidKeys.join(','),\n                        pattern: patternKey,\n                    }));\n                }\n            }\n            if (patternValue) {\n                const check = new RegExp(patternValue);\n                const invalidKeys: any[] = [];\n                Object.keys(value).forEach((key) => {\n                    const propertyValue = value[key];\n                    if (typeof propertyValue !== 'string' || !check.test(propertyValue)) invalidKeys.push(key);\n                });\n                if (invalidKeys.length) {\n                    fieldErrors.push(m('inputSchema.validation.objectValuesInvalid', {\n                        rootName: 'input',\n                        fieldKey: property,\n                        invalidKeys: invalidKeys.join(','),\n                        pattern: patternValue,\n                    }));\n                }\n            }\n        }\n        if (fieldErrors.length > 0) {\n            const message = fieldErrors.join(', ');\n            errors.push({ fieldKey: property, message });\n        }\n    });\n\n    return errors;\n}\n\n/**\n * This functions parses all given JSON and then takes each of the jsFields.\n * Then if the field:\n * - is valid JS single function it replaces its single line string with a function delacation.\n * - is valid multiline JS code then replaces its single line string with `multiline` string\n * Then stringifies the code with given number of jsonSpacing spaces and finally prefixes whole\n * stringified JSON except the first line with globalSpacing spaces.\n */\nexport function makeInputJsFieldsReadable(json: string, jsFields: string[], jsonSpacing = 4, globalSpacing = 0): string {\n    const parsedJson = JSON.parse(json);\n    const replacements: Record<string, any> = {};\n\n    jsFields.forEach((field) => {\n        let maybeFunction = parsedJson[field];\n        if (!maybeFunction || typeof maybeFunction !== 'string') return;\n\n        let ast;\n        try {\n            ast = parseScript(maybeFunction, { cst: true });\n        } catch (err) {\n            // Don't do anything in a case of invalid JS code.\n            return;\n        }\n\n        const isMultiline = maybeFunction.includes('\\n');\n        const isSingleFunction = ast\n            && ast.leafs\n            && ast.leafs.length === 1 // Must have only one expression inside!\n            && ast.leafs[0]\n            && (\n                // Normal function ...\n                ast.leafs[0].type === 'FunctionDeclaration'\n                // or arrow function\n                || (\n                    ast.leafs[0].type === 'ExpressionStatement'\n                    && (ast.leafs[0] as { expression: { type: string } }).expression.type === 'ArrowFunction'\n                )\n            );\n\n        // If it's not a function declaration or multiline JS code then we do nothing.\n        if (!isSingleFunction && !isMultiline) return;\n\n        const spaces = (new Array(isSingleFunction ? jsonSpacing : jsonSpacing * 2)).fill(' ').join('');\n        maybeFunction = maybeFunction\n            .split('\\n').join(`\\n${spaces}`) // This prefixes each line with spaces.\n            .trim(); // Trim whitespace on both sides\n\n        const replacementValue = isSingleFunction\n            ? maybeFunction.replace(/[;]+$/g, '') // Remove trailing semicolons\n            : `\\`${maybeFunction}\\``;\n        const replacementToken = `<<<REPLACEMENT_TOKEN:${Math.random()}>>>`;\n        replacements[replacementToken] = replacementValue;\n        parsedJson[field] = replacementToken;\n    });\n\n    let niceJson = JSON.stringify(parsedJson, null, jsonSpacing);\n\n    Object.entries(replacements).forEach(([replacementToken, replacementValue]) => {\n        niceJson = niceJson.replace(`\"${replacementToken}\"`, replacementValue);\n    });\n\n    const globalSpaces = (new Array(globalSpacing)).fill(' ').join('');\n    niceJson = niceJson.split('\\n').join(`\\n${globalSpaces}`);\n\n    return niceJson;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,9 +1,17 @@
 {
     "name": "@apify/input_schema",
-    "version": "2.1.0",
+    "version": "3.1.0",
     "description": "Tools and constants shared across Apify projects.",
-    "main": "index.js",
-    "typings": "index.d.ts",
+    "main": "./index.js",
+    "module": "./index.mjs",
+    "typings": "./index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./index.mjs",
+            "require": "./index.js",
+            "types": "./index.d.ts"
+        }
+    },
     "keywords": [
         "apify"
     ],
@@ -28,19 +36,19 @@
     "scripts": {
         "build": "npm run clean && npm run compile && npm run copy",
         "clean": "rimraf ./dist",
-        "compile": "tsc -p tsconfig.build.json",
-        "copy": "ts-node -T ../../scripts/copy.ts"
+        "compile": "tsup && tsc -p tsconfig.build.json",
+        "copy": "ts-node -T ../../scripts/copy.ts && ts-node -T ./scripts/copy-schema.ts"
     },
     "publishConfig": {
         "access": "public"
     },
     "dependencies": {
-        "@apify/consts": "^1.11.0",
+        "@apify/consts": "^2.1.0",
         "countries-list": "^2.6.1",
         "escaya": "^0.0.61"
     },
     "peerDependencies": {
         "ajv": "^8.0.0"
     },
-    "gitHead": "ed4bf3b571073ea64aa2ed0ba4ee264ba5d269c6"
+    "gitHead": "0e506c93a3f45910b294c163b63f9dc3c32b6143"
 }

package/schema.json

@@ -63,6 +63,7 @@
                 "nullable": { "type": "boolean" },
                 "sectionCaption": { "type": "string" },
                 "sectionDescription": { "type": "string" },
+
                 "enum": {
                     "type": "array",
                     "items": { "type": "string" }
@@ -114,6 +115,7 @@
                 "minItems": { "type": "integer" },
                 "maxItems": { "type": "integer" },
                 "uniqueItems": { "type": "boolean" },
+
                 "editor": { "enum": ["json", "requestListSources", "pseudoUrls", "keyValue", "stringList", "hidden"] },
                 "sectionCaption": { "type": "string" },
                 "sectionDescription": { "type": "string" }
@@ -136,6 +138,7 @@
                 "nullable": { "type": "boolean" },
                 "minProperties": { "type": "integer" },
                 "maxProperties": { "type": "integer" },
+
                 "editor": { "enum": ["json", "proxy", "hidden"] },
                 "sectionCaption": { "type": "string" },
                 "sectionDescription": { "type": "string" }

package/input_schema.js

@@ -1,123 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateInputSchema = exports.parseAjvError = exports.inputSchema = void 0;
-const schema_json_1 = __importDefault(require("./schema.json"));
-exports.inputSchema = schema_json_1.default;
-const intl_1 = require("./intl");
-const { definitions } = schema_json_1.default;
-/**
- * This function parses AJV error and transforms it into a readable string.
- *
- * @param error An error as returned from AJV.
- * @param rootName Usually 'input' or 'schema' based on if we are passing the input or schema.
- * @param properties (Used only when parsing input errors) List of input schema properties.
- * @param input (Used only when parsing input errors) Actual input that is being parsed.
- * @returns {null|{fieldKey: *, message: *}}
- */
-function parseAjvError(error, rootName, properties = {}, input = {}) {
-    // There are 3 possible errors comming from validation:
-    // - either { keword: 'anything', instancePath: '/someField', message: 'error message that we can use' }
-    // - or { keyword: 'additionalProperties', params: { additionalProperty: 'field' }, message: 'must NOT have additional properties' }
-    // - or { keyword: 'required', instancePath: '', params.missingProperty: 'someField' }
-    let fieldKey;
-    let message;
-    // If error is with keyword type, it means that type of input is incorrect
-    // this can mean that provided value is null
-    if (error.keyword === 'type') {
-        fieldKey = error.instancePath.split('/').pop();
-        // Check if value is null and field is nullable, if yes, then skip this error
-        if (properties[fieldKey] && properties[fieldKey].nullable && input[fieldKey] === null) {
-            return null;
-        }
-        message = (0, intl_1.m)('inputSchema.validation.generic', { rootName, fieldKey, message: error.message });
-    }
-    else if (error.keyword === 'required') {
-        fieldKey = error.params.missingProperty;
-        message = (0, intl_1.m)('inputSchema.validation.required', { rootName, fieldKey });
-    }
-    else if (error.keyword === 'additionalProperties') {
-        fieldKey = error.params.additionalProperty;
-        message = (0, intl_1.m)('inputSchema.validation.additionalProperty', { rootName, fieldKey });
-    }
-    else {
-        fieldKey = error.instancePath.split('/').pop();
-        message = (0, intl_1.m)('inputSchema.validation.generic', { rootName, fieldKey, message: error.message });
-    }
-    return { fieldKey, message };
-}
-exports.parseAjvError = parseAjvError;
-/**
- * Validates given object against schema and throws a human readable error.
- */
-const validateAgainstSchemaOrThrow = (validator, obj, inputSchema, rootName) => {
-    var _a;
-    if (validator.validate(inputSchema, obj))
-        return;
-    const errorMessage = (_a = parseAjvError(validator.errors[0], rootName)) === null || _a === void 0 ? void 0 : _a.message;
-    throw new Error(`Input schema is not valid (${errorMessage})`);
-};
-/**
- * This validates given object only against the basic input schema without checking the particular fields.
- * We override schema.properties.properties not to validate field defitions.
- */
-const validateBasicStructure = (validator, obj) => {
-    const schemaWithoutProperties = Object.assign({}, schema_json_1.default);
-    schemaWithoutProperties.properties = Object.assign(Object.assign({}, schema_json_1.default.properties), { properties: { type: 'object' } });
-    validateAgainstSchemaOrThrow(validator, obj, schemaWithoutProperties, 'schema');
-};
-/**
- * Validates particular field against it's schema.
- */
-const validateField = (validator, fieldSchema, fieldKey) => {
-    const matchingDefinitions = Object
-        .values(definitions) // cast as any, as the code in first branch seems to be invalid
-        .filter((definition) => {
-        return definition.properties.type.enum
-            // This is a normal case where fieldSchema.type can be only one possible value matching definition.properties.type.enum.0
-            ? definition.properties.type.enum[0] === fieldSchema.type
-            // This is a type "Any" where fieldSchema.type is an array of possible values
-            : Array.isArray(fieldSchema.type);
-    });
-    // There is not matching definition.
-    if (matchingDefinitions.length === 0) {
-        const errorMessage = (0, intl_1.m)('inputSchema.validation.noMatchingDefinition', { fieldKey });
-        throw new Error(`Input schema is not valid (${errorMessage})`);
-    }
-    // If there is only one matching then we are done and simply compare it.
-    if (matchingDefinitions.length === 1) {
-        validateAgainstSchemaOrThrow(validator, fieldSchema, matchingDefinitions[0], `schema.properties.${fieldKey}`);
-        return;
-    }
-    // If there are more matching definitions then the type is string and we need to get the right one.
-    // If the definition contains "enum" property then it's enum type.
-    if (fieldSchema.enum) {
-        const definition = matchingDefinitions.filter((item) => !!item.properties.enum).pop();
-        if (!definition)
-            throw new Error('Input schema validation failed to find "enum property" definition');
-        validateAgainstSchemaOrThrow(validator, fieldSchema, definition, `schema.properties.${fieldKey}.enum`);
-        return;
-    }
-    // Otherwise we use the other definition.
-    const definition = matchingDefinitions.filter((item) => !item.properties.enum).pop();
-    if (!definition)
-        throw new Error('Input schema validation failed to find other than "enum property" definition');
-    validateAgainstSchemaOrThrow(validator, fieldSchema, definition, `schema.properties.${fieldKey}`);
-};
-/**
- * This function validates given input schema first just for basic structure then each field one by one and
- * finally fully against the whole schema.
- *
- * This way we get the most accurate error message for user.
- */
-function validateInputSchema(validator, inputSchema) {
-    // First validate just basic structure without fields.
-    validateBasicStructure(validator, inputSchema);
-    // Then validate each field separately.
-    Object.entries(inputSchema.properties).forEach(([fieldKey, fieldSchema]) => validateField(validator, fieldSchema, fieldKey));
-    // Finally just to be sure run validation against the whole shema.
-    validateAgainstSchemaOrThrow(validator, inputSchema, schema_json_1.default, 'schema');
-}
-exports.validateInputSchema = validateInputSchema;

package/intl.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.m = void 0;
-/* eslint-disable max-len,quotes,quote-props */
-const intlStrings = {
-    'inputSchema.validation.generic': 'Field {rootName}.{fieldKey} {message}',
-    'inputSchema.validation.required': 'Field {rootName}.{fieldKey} is required',
-    'inputSchema.validation.proxyRequired': 'Field {rootName}.{fieldKey} is required. Please provide custom proxy URLs or use Apify Proxy.',
-    'inputSchema.validation.requestListSourcesInvalid': 'Items in {rootName}.{fieldKey} at positions [{invalidIndexes}] do not contain valid URLs',
-    'inputSchema.validation.arrayKeysInvalid': 'Keys in {rootName}.{fieldKey} at positions [{invalidIndexes}] must match regular expression "{pattern}"',
-    'inputSchema.validation.arrayValuesInvalid': 'Values in {rootName}.{fieldKey} at positions [{invalidIndexes}] must match regular expression "{pattern}"',
-    'inputSchema.validation.objectKeysInvalid': 'Keys [{invalidKeys}] in {rootName}.{fieldKey} must match regular expression "{pattern}',
-    'inputSchema.validation.objectValuesInvalid': 'Keys [{invalidKeys}] in {rootName}.{fieldKey} must have string value which matches regular expression "{pattern}"',
-    'inputSchema.validation.additionalProperty': 'Property {rootName}.{fieldKey} is not allowed.',
-    'inputSchema.validation.proxyGroupsNotAvailable': 'You currently do not have access to proxy groups: {groups}',
-    'inputSchema.validation.customProxyInvalid': 'Proxy URL "{invalidUrl}" has invalid format, it must be http://[username[:password]]@hostname:port.',
-    'inputSchema.validation.apifyProxyCountryInvalid': 'Country code "{invalidCountry}" is invalid. Only ISO 3166-1 alpha-2 country codes are supported.',
-    'inputSchema.validation.apifyProxyCountryWithoutApifyProxyForbidden': 'The country for Apify Proxy can be specified only when using Apify Proxy.',
-    'inputSchema.validation.noAvailableAutoProxy': 'Currently you do not have access to any proxy group usable in automatic mode.',
-    'inputSchema.validation.noMatchingDefinition': 'Field schema.properties.{fieldKey} is not matching any input schema type definition. Please make sure that it\'s type is valid.',
-};
-/* eslint-enable max-len,quotes,quote-props */
-/**
- * Helper function to simulate intl formatMessage function
- */
-function m(stringId, variables) {
-    let text = intlStrings[stringId];
-    if (!text)
-        return stringId;
-    if (variables) {
-        Object.keys(variables).forEach((variableName) => {
-            text = text.split(`{${variableName}}`).join(variables[variableName]);
-        });
-    }
-    return text;
-}
-exports.m = m;

package/utilities.js

@@ -1,294 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeInputJsFieldsReadable = exports.validateInputUsingValidator = void 0;
-const consts_1 = require("@apify/consts");
-const countries_list_1 = require("countries-list");
-const escaya_1 = require("escaya");
-const intl_1 = require("./intl");
-const input_schema_1 = require("./input_schema");
-/**
- * Validates input field configured with proxy editor
- * @param fieldKey Proxy field value
- * @param value Proxy field value
- * @param [isRequired] Whether the field is required or not
- * @param [options] Information about proxy groups availability
- * @param [options.hasAutoProxyGroups] Informs validation whether user has atleast one proxy group available in auto mode
- * @param [options.availableProxyGroups] List of available proxy groups
- * @param [options.disabledProxyGroups] Object with groupId as key and error message as value (mostly for residential/SERP)
- */
-function validateProxyField(fieldKey, value, isRequired = false, options = null) {
-    const fieldErrors = [];
-    if (isRequired) {
-        // Nullable error is already handled by AJV
-        if (value === null)
-            return fieldErrors;
-        if (!value) {
-            const message = (0, intl_1.m)('inputSchema.validation.required', { rootName: 'input', fieldKey });
-            fieldErrors.push(message);
-            return fieldErrors;
-        }
-        const { useApifyProxy, proxyUrls } = value;
-        if (!useApifyProxy && (!Array.isArray(proxyUrls) || proxyUrls.length === 0)) {
-            fieldErrors.push((0, intl_1.m)('inputSchema.validation.proxyRequired', { rootName: 'input', fieldKey }));
-            return fieldErrors;
-        }
-    }
-    // Input is not required, so missing value is valid
-    if (!value)
-        return fieldErrors;
-    const { useApifyProxy, proxyUrls, apifyProxyGroups, apifyProxyCountry } = value;
-    if (!useApifyProxy && Array.isArray(proxyUrls)) {
-        let invalidUrl = false;
-        proxyUrls.forEach((url) => {
-            if (!consts_1.PROXY_URL_REGEX.test(url.trim()))
-                invalidUrl = url.trim();
-        });
-        if (invalidUrl) {
-            fieldErrors.push((0, intl_1.m)('inputSchema.validation.customProxyInvalid', { invalidUrl }));
-        }
-    }
-    // Apify proxy country can be set only when using Apify proxy
-    if (!useApifyProxy && apifyProxyCountry) {
-        fieldErrors.push((0, intl_1.m)('inputSchema.validation.apifyProxyCountryWithoutApifyProxyForbidden'));
-    }
-    // If Apify proxy is not used skip additional checks
-    if (!useApifyProxy)
-        return fieldErrors;
-    // If Apify proxy is used, check if there is a selected country and if so, check that it's valid (empty or a valid country code)
-    if (apifyProxyCountry && !countries_list_1.countries[apifyProxyCountry]) {
-        fieldErrors.push((0, intl_1.m)('inputSchema.validation.apifyProxyCountryInvalid', { invalidCountry: apifyProxyCountry }));
-    }
-    // If options are not provided skip additional checks
-    if (!options)
-        return fieldErrors;
-    const selectedProxyGroups = (apifyProxyGroups || []);
-    // Auto mode, check that user has access to alteast one proxy group usable in this mode
-    if (!selectedProxyGroups.length && !options.hasAutoProxyGroups) {
-        fieldErrors.push((0, intl_1.m)('inputSchema.validation.noAvailableAutoProxy'));
-        return fieldErrors;
-    }
-    // Check if proxy groups selected by user are available to him
-    const availableProxyGroupsById = {};
-    (options.availableProxyGroups || []).forEach((group) => { availableProxyGroupsById[group] = true; });
-    const unavailableProxyGroups = selectedProxyGroups.filter((group) => !availableProxyGroupsById[group]);
-    if (unavailableProxyGroups.length) {
-        fieldErrors.push((0, intl_1.m)('inputSchema.validation.proxyGroupsNotAvailable', {
-            rootName: 'input',
-            fieldKey,
-            groups: unavailableProxyGroups.join(', '),
-        }));
-    }
-    // Check if any of the proxy groups are blocked and if yes then output the associated message
-    const blockedProxyGroupsById = options.disabledProxyGroups || {};
-    selectedProxyGroups
-        .filter((group) => blockedProxyGroupsById[group])
-        .forEach((blockedGroup) => {
-        fieldErrors.push(blockedProxyGroupsById[blockedGroup]);
-    });
-    return fieldErrors;
-}
-/**
- * Uses AJV validator to validate input with input schema and then
- * does custom validation for our own properties (nullable, patternKey, patternValue)
- * @param validator Initialized AJV validator
- * @param inputSchema Valid input schema in object
- * @param input Input object to be validated
- * @param options (Optional) Additional validation configuration for certain fields
- */
-function validateInputUsingValidator(validator, inputSchema, input, options = {}) {
-    const isValid = validator(input); // Check if input is valid based on schema values
-    const { properties } = inputSchema;
-    const required = inputSchema.required || [];
-    let errors = [];
-    // Process AJV validation errors
-    if (!isValid) {
-        errors = validator.errors
-            .map((error) => (0, input_schema_1.parseAjvError)(error, 'input', properties, input))
-            .filter((error) => !!error);
-    }
-    Object.keys(properties).forEach((property) => {
-        const value = input[property];
-        const { type, editor, patternKey, patternValue } = properties[property];
-        const fieldErrors = [];
-        // Check that proxy is required, if yes, valides that it's correctly setup
-        if (type === 'object' && editor === 'proxy') {
-            const proxyValidationErrors = validateProxyField(property, value, required.includes(property), options.proxy);
-            proxyValidationErrors.forEach((error) => {
-                fieldErrors.push(error);
-            });
-        }
-        // Check that array items fit patternKey and patternValue
-        if (type === 'array' && value && Array.isArray(value)) {
-            if (editor === 'requestListSources') {
-                const invalidIndexes = [];
-                value.forEach((item, index) => {
-                    if (!item)
-                        invalidIndexes.push(index);
-                    else if (!item.url && !item.requestsFromUrl)
-                        invalidIndexes.push(index);
-                    else if (item.url && !consts_1.URL_REGEX.test(item.url))
-                        invalidIndexes.push(index);
-                    else if (item.requestsFromUrl && !consts_1.URL_REGEX.test(item.requestsFromUrl))
-                        invalidIndexes.push(index);
-                });
-                if (invalidIndexes.length) {
-                    fieldErrors.push((0, intl_1.m)('inputSchema.validation.requestListSourcesInvalid', {
-                        rootName: 'input',
-                        fieldKey: property,
-                        invalidIndexes: invalidIndexes.join(','),
-                    }));
-                }
-            }
-            // If patternKey is provided, then validate keys of objects in array
-            if (patternKey && editor === 'keyValue') {
-                const check = new RegExp(patternKey);
-                const invalidIndexes = [];
-                value.forEach((item, index) => {
-                    if (!check.test(item.key))
-                        invalidIndexes.push(index);
-                });
-                if (invalidIndexes.length) {
-                    fieldErrors.push((0, intl_1.m)('inputSchema.validation.arrayKeysInvalid', {
-                        rootName: 'input',
-                        fieldKey: property,
-                        invalidIndexes: invalidIndexes.join(','),
-                        pattern: patternKey,
-                    }));
-                }
-            }
-            // If patternValue is provided and editor is keyValue, then validate values of objecs in array
-            if (patternValue && editor === 'keyValue') {
-                const check = new RegExp(patternValue);
-                const invalidIndexes = [];
-                value.forEach((item, index) => {
-                    if (!check.test(item.value))
-                        invalidIndexes.push(index);
-                });
-                if (invalidIndexes.length) {
-                    fieldErrors.push((0, intl_1.m)('inputSchema.validation.arrayValuesInvalid', {
-                        rootName: 'input',
-                        fieldKey: property,
-                        invalidIndexes: invalidIndexes.join(','),
-                        pattern: patternValue,
-                    }));
-                }
-                // If patternValue is provided and editor is stringList, then validate each item in array
-            }
-            else if (patternValue && editor === 'stringList') {
-                const check = new RegExp(patternValue);
-                const invalidIndexes = [];
-                value.forEach((item, index) => {
-                    if (!check.test(item))
-                        invalidIndexes.push(index);
-                });
-                if (invalidIndexes.length) {
-                    fieldErrors.push((0, intl_1.m)('inputSchema.validation.arrayValuesInvalid', {
-                        rootName: 'input',
-                        fieldKey: property,
-                        invalidIndexes: invalidIndexes.join(','),
-                        pattern: patternValue,
-                    }));
-                }
-            }
-        }
-        // Check that object items fit patternKey and patternValue
-        if (type === 'object' && value) {
-            if (patternKey) {
-                const check = new RegExp(patternKey);
-                const invalidKeys = [];
-                Object.keys(value).forEach((key) => {
-                    if (!check.test(key))
-                        invalidKeys.push(key);
-                });
-                if (invalidKeys.length) {
-                    fieldErrors.push((0, intl_1.m)('inputSchema.validation.objectKeysInvalid', {
-                        rootName: 'input',
-                        fieldKey: property,
-                        invalidKeys: invalidKeys.join(','),
-                        pattern: patternKey,
-                    }));
-                }
-            }
-            if (patternValue) {
-                const check = new RegExp(patternValue);
-                const invalidKeys = [];
-                Object.keys(value).forEach((key) => {
-                    const propertyValue = value[key];
-                    if (typeof propertyValue !== 'string' || !check.test(propertyValue))
-                        invalidKeys.push(key);
-                });
-                if (invalidKeys.length) {
-                    fieldErrors.push((0, intl_1.m)('inputSchema.validation.objectValuesInvalid', {
-                        rootName: 'input',
-                        fieldKey: property,
-                        invalidKeys: invalidKeys.join(','),
-                        pattern: patternValue,
-                    }));
-                }
-            }
-        }
-        if (fieldErrors.length > 0) {
-            const message = fieldErrors.join(', ');
-            errors.push({ fieldKey: property, message });
-        }
-    });
-    return errors;
-}
-exports.validateInputUsingValidator = validateInputUsingValidator;
-/**
- * This functions parses all given JSON and then takes each of the jsFields.
- * Then if the field:
- * - is valid JS single function it replaces its single line string with a function delacation.
- * - is valid multiline JS code then replaces its single line string with `multiline` string
- * Then stringifies the code with given number of jsonSpacing spaces and finally prefixes whole
- * stringified JSON except the first line with globalSpacing spaces.
- */
-function makeInputJsFieldsReadable(json, jsFields, jsonSpacing = 4, globalSpacing = 0) {
-    const parsedJson = JSON.parse(json);
-    const replacements = {};
-    jsFields.forEach((field) => {
-        let maybeFunction = parsedJson[field];
-        if (!maybeFunction || typeof maybeFunction !== 'string')
-            return;
-        let ast;
-        try {
-            ast = (0, escaya_1.parseScript)(maybeFunction, { cst: true });
-        }
-        catch (err) {
-            // Don't do anything in a case of invalid JS code.
-            return;
-        }
-        const isMultiline = maybeFunction.includes('\n');
-        const isSingleFunction = ast
-            && ast.leafs
-            && ast.leafs.length === 1 // Must have only one expression inside!
-            && ast.leafs[0]
-            && (
-            // Normal function ...
-            ast.leafs[0].type === 'FunctionDeclaration'
-                // or arrow function
-                || (ast.leafs[0].type === 'ExpressionStatement'
-                    && ast.leafs[0].expression.type === 'ArrowFunction'));
-        // If it's not a function declaration or multiline JS code then we do nothing.
-        if (!isSingleFunction && !isMultiline)
-            return;
-        const spaces = (new Array(isSingleFunction ? jsonSpacing : jsonSpacing * 2)).fill(' ').join('');
-        maybeFunction = maybeFunction
-            .split('\n').join(`\n${spaces}`) // This prefixes each line with spaces.
-            .trim(); // Trim whitespace on both sides
-        const replacementValue = isSingleFunction
-            ? maybeFunction.replace(/[;]+$/g, '') // Remove trailing semicolons
-            : `\`${maybeFunction}\``;
-        const replacementToken = `<<<REPLACEMENT_TOKEN:${Math.random()}>>>`;
-        replacements[replacementToken] = replacementValue;
-        parsedJson[field] = replacementToken;
-    });
-    let niceJson = JSON.stringify(parsedJson, null, jsonSpacing);
-    Object.entries(replacements).forEach(([replacementToken, replacementValue]) => {
-        niceJson = niceJson.replace(`"${replacementToken}"`, replacementValue);
-    });
-    const globalSpaces = (new Array(globalSpacing)).fill(' ').join('');
-    niceJson = niceJson.split('\n').join(`\n${globalSpaces}`);
-    return niceJson;
-}
-exports.makeInputJsFieldsReadable = makeInputJsFieldsReadable;