@appsemble/utils 0.30.14-test.5 → 0.32.1-test.14

package/reference-schemas/actions/resources.js

@@ -0,0 +1,19 @@
+import { ResourceCountActionDefinition, ResourceCreateActionDefinition, ResourceDeleteActionDefinition, ResourceDeleteAllActionDefinition, ResourceDeleteBulkActionDefinition, ResourceGetActionDefinition, ResourceHistoryGetActionDefinition, ResourcePatchActionDefinition, ResourceQueryActionDefinition, ResourceSubscriptionStatusActionDefinition, ResourceSubscriptionSubscribeActionDefinition, ResourceSubscriptionToggleActionDefinition, ResourceSubscriptionUnsubscribeActionDefinition, ResourceUpdateActionDefinition, ResourceUpdatePositionsActionDefinition, } from '../../api/components/schemas/index.js';
+export const resourceActions = {
+    'resource.get': ResourceGetActionDefinition,
+    'resource.history.get': ResourceHistoryGetActionDefinition,
+    'resource.update.positions': ResourceUpdatePositionsActionDefinition,
+    'resource.query': ResourceQueryActionDefinition,
+    'resource.count': ResourceCountActionDefinition,
+    'resource.create': ResourceCreateActionDefinition,
+    'resource.update': ResourceUpdateActionDefinition,
+    'resource.patch': ResourcePatchActionDefinition,
+    'resource.delete': ResourceDeleteActionDefinition,
+    'resource.delete.all': ResourceDeleteAllActionDefinition,
+    'resource.delete.bulk': ResourceDeleteBulkActionDefinition,
+    'resource.subscription.subscribe': ResourceSubscriptionSubscribeActionDefinition,
+    'resource.subscription.unsubscribe': ResourceSubscriptionUnsubscribeActionDefinition,
+    'resource.subscription.toggle': ResourceSubscriptionToggleActionDefinition,
+    'resource.subscription.status': ResourceSubscriptionStatusActionDefinition,
+};
+//# sourceMappingURL=resources.js.map

package/reference-schemas/actions/storage.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAPIV3 } from 'openapi-types';
+export declare const storageActions: Record<string, OpenAPIV3.SchemaObject>;

package/reference-schemas/actions/storage.js

@@ -0,0 +1,15 @@
+import { StorageAppendActionDefinition } from '../../api/components/schemas/StorageAppendActionDefinition.js';
+import { StorageDeleteActionDefinition } from '../../api/components/schemas/StorageDeleteActionDefinition.js';
+import { StorageReadActionDefinition } from '../../api/components/schemas/StorageReadActionDefinition.js';
+import { StorageSubtractActionDefinition } from '../../api/components/schemas/StorageSubtractActionDefinition.js';
+import { StorageUpdateActionDefinition } from '../../api/components/schemas/StorageUpdateActionDefinition.js';
+import { StorageWriteActionDefinition } from '../../api/components/schemas/StorageWriteActionDefinition.js';
+export const storageActions = {
+    'storage.read': StorageReadActionDefinition,
+    'storage.write': StorageWriteActionDefinition,
+    'storage.append': StorageAppendActionDefinition,
+    'storage.subtract': StorageSubtractActionDefinition,
+    'storage.update': StorageUpdateActionDefinition,
+    'storage.delete': StorageDeleteActionDefinition,
+};
+//# sourceMappingURL=storage.js.map

package/reference-schemas/remappers/conditionals.js

@@ -124,5 +124,44 @@ ${schemaExample('match')}
             },
         },
     },
+    and: {
+        type: 'array',
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `Compare all computed remapper values against each other.
+
+Returns \`true\` if all entries are equal to \`true\`, otherwise \`false\`.
+
+If only one remapper or none is passed, the remapper value gets computed.
+
+${schemaExample('and')}
+`,
+    },
+    or: {
+        type: 'array',
+        items: {
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `Compare all computed remapper values against each other.
+
+Returns \`false\` if all entries are equal to \`false\`, otherwise \`true\`.
+
+If only one remapper or none is passed, the remapper value gets computed.
+
+${schemaExample('or')}
+`,
+    },
+    defined: {
+        $ref: '#/components/schemas/RemapperDefinition',
+        description: `Check if a value is defined. Returns \`true\` if defined, \`false\` if not.
+
+Considers falsy values like \`0\`, \`""\` and \`false\` as defined.
+
+The \`null\` and \`undefined\` values are considered as not defined.
+
+${schemaExample('defined')}
+`,
+    },
 };
 //# sourceMappingURL=conditionals.js.map

package/reference-schemas/remappers/data.js

@@ -1,8 +1,8 @@
 import { schemaExample } from '../../examples.js';
 export const dataRemappers = {
     array: {
-        enum: ['index', 'length', 'item'],
-        description: `Get the current array.map’s index, length or the current item.
+        enum: ['index', 'length', 'item', 'prevItem', 'nextItem'],
+        description: `Get the current array.map’s index, length, the current item, previous item or next item.
 
 Returns nothing when not in the context of \`array.map’s\`.
 
@@ -237,6 +237,14 @@ The result of the final page’s log would then be:
         description: `Gets the chosen property from an object.
 
 ${schemaExample('prop')}
+`,
+    },
+    len: {
+        enum: [null],
+        description: `
+Returns the length of an input array or an input string, unlike { array: length } remapper this remapper does not require
+an array to be in the context. This can be very useful when working with nested arrays.
+${schemaExample('len')}
 `,
     },
     root: {
@@ -366,5 +374,21 @@ Example:
 \`\`\`
     `,
     },
+    slice: {
+        description: `Extract characters from a string, or items from an array
+accepts either an array of two numbers (indexes of starting point and ending point)
+or a number (index of the starting point).
+startIndex is inclusive whereas the endIndex is not.
+${schemaExample('slice')}`,
+        oneOf: [
+            {
+                type: 'array',
+                items: {
+                    type: 'number',
+                },
+            },
+            { type: 'number' },
+        ],
+    },
 };
 //# sourceMappingURL=data.js.map

package/reference-schemas/remappers/index.d.ts

@@ -9,3 +9,4 @@ export * from './strings.js';
 export * from './unsorted.js';
 export * from './config.js';
 export * from './numbers.js';
+export * from './odata.js';

package/reference-schemas/remappers/index.js

@@ -9,4 +9,5 @@ export * from './strings.js';
 export * from './unsorted.js';
 export * from './config.js';
 export * from './numbers.js';
+export * from './odata.js';
 //# sourceMappingURL=index.js.map

package/reference-schemas/remappers/objects.js

@@ -89,6 +89,38 @@ value? Then you can use \`object.omit\`. The remapper can remove properties from
 based on the given object keys. This includes nested properties.
 
 ${schemaExample('object.omit', { input: 'pretty', result: 'pretty' })}
+`,
+    },
+    'object.compare': {
+        type: 'array',
+        items: {
+            minItems: 2,
+            maxItems: 2,
+            $ref: '#/components/schemas/RemapperDefinition',
+        },
+        description: `
+
+This remapper allows you to compare two objects and get differences in their key-value pairs like in the following example:
+
+${schemaExample('object.compare', { input: 'pretty', result: 'pretty' })}
+`,
+    },
+    'object.explode': {
+        type: 'string',
+        description: `
+
+Takes an object with an array property and transforms it into an array of objects.
+
+Each object in the resulting array contains all the entries of the original object
+plus all the entries of the corresponding array item from the array property.
+
+If one of the items in the array contains a key, which exists in the original object
+it will overwrite the original key.
+
+Nested arrays or objects are not exploded.
+
+Example:
+${schemaExample('object.explode', { input: 'pretty', result: 'pretty' })}
 `,
     },
 };

package/reference-schemas/remappers/odata.d.ts

@@ -0,0 +1,2 @@
+import { type OpenAPIV3 } from 'openapi-types';
+export declare const odataRemappers: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>;

package/reference-schemas/remappers/odata.js

@@ -0,0 +1,95 @@
+import { schemaExample } from '../../examples.js';
+export const odataRemappers = {
+    'filter.from': {
+        additionalProperties: {
+            $ref: '#/components/schemas/FilterParametersDefinition',
+        },
+        description: `
+
+With this remapper you can generate an OData filter, ready to be passed to the \`$filter\` key in
+resource queries.
+
+The different comparator options are as follows:
+
+- eq - Equal to
+- ne - Not equal to
+- lt - Less than
+- gt - Greater than
+- le - Less than or equal to
+- ge - Greater than or equal to
+
+The most common types of values are \`String\`, \`Number\`, \`Boolean\` and \`Date\`. If you need a more specific
+type, please refer to [the OData spec](https://www.odata.org/documentation/odata-version-2-0/overview/).
+
+As a base, the remapper looks like this:
+
+${schemaExample('filter.from')}
+
+Here is an example of how you can use the remapper in an app definition:
+
+\`\`\`yaml
+type: resource.query
+  resource: myResource
+  query:
+    object.from:
+      $filter:
+        filter.from:
+          name:
+            type: String
+            comparator: ne
+            value: { prop: exclude }
+          age:
+            type: Int64
+            comparator: lt
+            value: 10
+          birthday:
+            type: Date
+            comparator: ge
+            value: '2000-01-01'
+          job:
+            type: String
+            comparator: eq
+            value: null
+          employed:
+            type: Boolean
+            comparator: eq
+            value: false
+          special:
+            type: String
+            comparator: eq
+            value: "Special character's test"
+\`\`\`
+`,
+    },
+    'order.from': {
+        additionalProperties: {
+            enum: ['asc', 'desc'],
+        },
+        description: `
+
+With this remapper you can generate an OData order, ready to be passed to the \`$orderby\` key in
+resource queries.
+
+The different order options are as follows:
+
+- asc - Ascending
+- desc - Descending
+
+${schemaExample('order.from', { exclude: ['input'] })}
+
+Here is an example of how you can use the remapper in an app definition:
+
+\`\`\`yaml
+type: resource.query
+  resource: myResource
+  query:
+    object.from:
+      $orderby:
+        order.from:
+          name: asc
+          age: desc
+\`\`\`
+`,
+    },
+};
+//# sourceMappingURL=odata.js.map

package/reference-schemas/remappers/strings.js

@@ -5,6 +5,39 @@ export const stringRemappers = {
         description: `Convert a string to upper or lower case.
 
 ${schemaExample('string.case')}
+`,
+    },
+    'string.startsWith': {
+        type: 'string',
+        description: `Check if the initial characters of the string matches with the input string,
+this remapper is case-sensitive.
+${schemaExample('string.startsWith')}
+`,
+    },
+    'string.endsWith': {
+        oneOf: [
+            {
+                type: 'string',
+            },
+            {
+                type: 'object',
+                description: 'Alternative way to define input to facilitate the case-insensitive matching',
+                required: ['substring'],
+                additionalProperties: false,
+                properties: {
+                    substring: {
+                        type: 'string',
+                    },
+                    strict: {
+                        type: 'boolean',
+                    },
+                },
+            },
+        ],
+        description: `Check if the last characters of the string matches with the input string,
+this remapper is case-sensitive unless specified explicitly,
+To make the remapper ignore casing of the input and passed string, use the following example
+${schemaExample('string.endsWith')}
 `,
     },
     'string.format': {

package/reference-schemas/remappers/unsorted.js

@@ -1,3 +1,4 @@
+import { schemaExample } from '../../examples.js';
 export const unsortedRemappers = {
     ics: {
         type: 'object',
@@ -248,5 +249,13 @@ For example:
 \`\`\`
 `,
     },
+    'xml.parse': {
+        description: `This can be used to parse an xml string into an object
+
+For example:
+
+${schemaExample('xml.parse', { result: 'pretty' })}`,
+        $ref: '#/components/schemas/RemapperDefinition',
+    },
 };
 //# sourceMappingURL=unsorted.js.map

package/remap.d.ts

@@ -60,6 +60,8 @@ interface InternalContext extends RemapperContext {
         index: number;
         length: number;
         item: unknown;
+        prevItem: unknown;
+        nextItem: unknown;
     };
     stepRef?: {
         current: Record<string, any>;