@appsemble/utils 0.33.5 → 0.33.7

package/reference-schemas/remappers/history.js

@@ -1,246 +0,0 @@
-export const historyRemappers = {
-    'from.history': {
-        type: 'object',
-        required: ['index', 'props'],
-        description: `Creates a new object based on the specified properties in the given history index. This can be very
-useful when you want to combine two sources of data together. It’s also cleaner than separately
-using \`object.from\` together with \`history\`.
-
-In the following example, you can see why this might be handy. Let’s say you get the details about a
-concert from a source like an action or a block. You have this information and then you want to get
-some additional data like the attendees of the concert. With \`from.history\` you can combine the
-older data like the name and date, and add the new \`attendees\` data. The result will be an object
-with this combined data.
-
-History index 1:
-
-\`\`\`json
-{
-  "name": "Rolling stones at Amsterdam Arena",
-  "artist": "Rolling Stones",
-  "location": "Amsterdam Arena",
-  "date": "07-07-2022",
-  "price": 120
-}
-\`\`\`
-
-Input:
-
-\`\`\`json
-[ .. ]
-\`\`\`
-
-\`\`\`yaml
-object.from:
-  concertDetails:
-    from.history:
-      index: 1
-      props:
-        name: { prop: name }
-        date: { prop: date }
-        attendees: { root: null }
-\`\`\`
-
-Result:
-
-\`\`\`json
-{
-  "concertDetails": {
-    "attendees": [ .. ],
-    "date": "07-07-2022",
-    "name": "Rolling stones at Amsterdam Arena"
-  }
-}
-\`\`\`
-`,
-        additionalProperties: false,
-        properties: {
-            index: {
-                type: 'integer',
-                description: `The index of the history stack item to assign.
-
-0 is the index of the first item in the history stack.
-`,
-            },
-            props: {
-                description: 'Predefined mapper keys to choose what properties to apply.',
-                additionalProperties: {
-                    $ref: '#/components/schemas/RemapperDefinition',
-                },
-            },
-        },
-    },
-    'assign.history': {
-        type: 'object',
-        required: ['index', 'props'],
-        description: `Assigns properties from the specified history stack index to an existing object.
-Similarly to the \`from.history\` remapper, this allows you to get a property from a place in the
-history and give it to a new object. The only difference here is that you are not creating an
-entirely new object, but you are taking an existing object and assigning new values to it.
-
-So, we can take the example from \`from.history\` and flip it.
-
-History index 1:
-
-\`\`\`json
-{
-  "peopleAmount": 3000
-}
-\`\`\`
-
-Input:
-
-\`\`\`json
-{
-  "name": "Rolling stones at Amsterdam Arena",
-  "artist": "Rolling Stones",
-  "location": "Amsterdam Arena",
-  "date": "07-07-2022",
-  "price": 120
-}
-\`\`\`
-
-\`\`\`yaml
-object.from:
-  concertDetails:
-    assign.history:
-      index: 1
-      props:
-        attendees: { prop: peopleAmount }
-\`\`\`
-
-Result:
-
-\`\`\`json
-{
-  "concertDetails": {
-    "name": "Rolling stones at Amsterdam Arena",
-    "artist": "Rolling Stones",
-    "location": "Amsterdam Arena",
-    "date": "07-07-2022",
-    "price": 120,
-    "attendees": 3000
-  }
-}
-\`\`\`
-`,
-        additionalProperties: false,
-        properties: {
-            index: {
-                type: 'integer',
-                description: `The index of the history stack item to assign.
-
-0 is the index of the first item in the history stack.
-`,
-            },
-            props: {
-                description: 'Predefined mapper keys to choose what properties to assign.',
-                additionalProperties: {
-                    $ref: '#/components/schemas/RemapperDefinition',
-                },
-            },
-        },
-    },
-    'omit.history': {
-        type: 'object',
-        required: ['index', 'keys'],
-        description: `Assigns properties from the specified history stack index to the current value and excludes the
-given properties.
-
-Similarly to the other history remappers, this gives you the data from a certain point in the
-history stack and allows you to modify it before adding to the current value. This one, however,
-allows you to take the complete specified history data and omit certain values.
-
-This remapper can be extremely helpful for re-using data you got before in the history stack while
-filtering certain properties.
-
-For example, let’s say you have the information for a concert but don’t want normal users to see
-sensitive data about it. Using \`omit.history\` you can take this concert data but exclude the
-sensitive parts.
-
-History index 1:
-
-\`\`\`json
-{
-  "name": "Rolling stones at Amsterdam Arena",
-  "artist": "Rolling Stones",
-  "location": "Amsterdam Arena",
-  "date": "07-07-2022",
-  "bandPasswords": [ .. ],
-  "bankDetailsAttendees": [ .. ]
-}
-\`\`\`
-
-Input:
-
-\`\`\`json
-[ .. ]
-\`\`\`
-
-\`\`\`yaml
-object.from:
-  concertDetails:
-    omit.history:
-      index: 1
-      keys:
-        - bandPasswords
-        - bankDetailsAttendees
-\`\`\`
-
-Result:
-
-\`\`\`json
-{
-  "concertDetails": {
-    "name": "Rolling stones at Amsterdam Arena",
-    "artist": "Rolling Stones",
-    "location": "Amsterdam Arena",
-    "date": "07-07-2022",
-    "attendees": [ .. ]
-  }
-}
-\`\`\`
-`,
-        additionalProperties: false,
-        properties: {
-            index: {
-                type: 'integer',
-                description: `The index of the history stack item to assign.
-
-0 is the index of the first item in the history stack.
-`,
-            },
-            keys: {
-                description: `Exclude properties from the history stack item, based on the given object keys.
-
-Nested properties can be excluded using arrays of keys.
-
-For example:
-\`\`\`yaml
-omit.history:
-  index: 0
-  keys:
-    - foo   # Excludes the property foo
-    - - bar # Excludes the property baz inside of bar
-      - baz
-\`\`\`
-`,
-                type: 'array',
-                items: {
-                    minItems: 1,
-                    anyOf: [
-                        { type: 'string' },
-                        {
-                            type: 'array',
-                            minItems: 2,
-                            items: {
-                                type: 'string',
-                            },
-                        },
-                    ],
-                },
-            },
-        },
-    },
-};
-//# sourceMappingURL=history.js.map

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

@@ -1,12 +0,0 @@
-export * from './arrays.js';
-export * from './conditionals.js';
-export * from './data.js';
-export * from './dates.js';
-export * from './history.js';
-export * from './objects.js';
-export * from './randoms.js';
-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

@@ -1,13 +0,0 @@
-export * from './arrays.js';
-export * from './conditionals.js';
-export * from './data.js';
-export * from './dates.js';
-export * from './history.js';
-export * from './objects.js';
-export * from './randoms.js';
-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/numbers.d.ts

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

package/reference-schemas/remappers/numbers.js

@@ -1,30 +0,0 @@
-import { schemaExample } from '../../examples.js';
-export const numberRemappers = {
-    'number.parse': {
-        anyOf: [
-            { enum: [null] },
-            { type: 'string' },
-            { $ref: '#/components/schemas/ArrayRemapperDefinition' },
-            { $ref: '#/components/schemas/ObjectRemapperDefinition' },
-        ],
-        description: `Convert a string into a number.
-
-If there is no remapper passed and the input can be converted, this will return the converted input.
-
-If there is no remapper passed and the input is null, this will return 0.
-
-If there is no remapper passed and the input cannot be converted, this will return the input.
-
-If there is a remapper passed and the remapped value can be converted, this will return the converted remapped value.
-
-If there is a remapper passed and the remapped value is null, this will return 0.
-
-If there is a remapper passed and the remapped value cannot be converted, this will return the remapped value.
-
-For example:
-
-${schemaExample('number.parse')}
-`,
-    },
-};
-//# sourceMappingURL=numbers.js.map

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

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

package/reference-schemas/remappers/objects.js

@@ -1,127 +0,0 @@
-import { schemaExample } from '../../examples.js';
-export const objectRemappers = {
-    'object.assign': {
-        additionalProperties: {
-            $ref: '#/components/schemas/RemapperDefinition',
-        },
-        description: `
-
-Let’s say you have an existing object that you want to add an additional value on top of. For this
-you can use the \`object.assign\` remapper. The remapper takes an existing object and allows the user
-to assign their own value on top of that.
-
-${schemaExample('object.assign')}
-
-`,
-    },
-    'object.from': {
-        additionalProperties: {
-            $ref: '#/components/schemas/RemapperDefinition',
-        },
-        description: `
-
-With this remapper you can create an entirely new object based on input values and other remappers.
-\`object.from\` itself accepts remapper functions as its input which allows you to chain multiple
-remappers together to make complex objects.
-
-As a base, the remapper looks like this:
-
-${schemaExample('object.from', { exclude: ['input'] })}
-
-Most of the time you won’t create an object just to store one value. Luckily, this is where the
-chaining of remappers comes in. You can create an object that contains an \`object.from\` remapper
-which then allows more inputs:
-
-\`\`\`yaml
-object.from:
-  username: Chris Taub
-  email: example@hotmail.com
-  addresses:
-    object.from:
-      work:
-        object.from:
-          city: Eindhoven
-          address: Nachtegaallaan 15
-      home:
-        object.from:
-          city: Amsterdam
-          address: Amstel 1
-\`\`\`
-
-\`\`\`json
-{
-  "username": "Chris Taub",
-  "email": "example@hotmail.com",
-  "addresses": {
-    "work": {
-      "city": "Eindhoven",
-      "address": "Nachtegaallaan 15"
-    },
-    "home": {
-      "city": "Amsterdam",
-      "address": "Amstel 1"
-    }
-  }
-}
-\`\`\`
-
-`,
-    },
-    'object.omit': {
-        type: 'array',
-        items: {
-            minItems: 1,
-            anyOf: [
-                { type: 'string' },
-                {
-                    type: 'array',
-                    minItems: 2,
-                    items: {
-                        type: 'string',
-                    },
-                },
-            ],
-        },
-        description: `
-
-In contrary to the previous remapper, what if you have an object from which you want to remove a
-value? Then you can use \`object.omit\`. The remapper can remove properties from an existing object
-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' })}
-`,
-    },
-};
-//# sourceMappingURL=objects.js.map

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

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

package/reference-schemas/remappers/odata.js

@@ -1,95 +0,0 @@
-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/randoms.d.ts

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

package/reference-schemas/remappers/randoms.js

@@ -1,82 +0,0 @@
-export const randomRemappers = {
-    'random.choice': {
-        enum: [null],
-        description: `Pick and return a random entry from an array. If the input is not an array, the input is returned as-is.
-For example:
-
-If you input the following array:
-\`\`\`json
-[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-\`\`\`
-
-\`\`\`yaml
-random.choice: null
-\`\`\`
-
-The result could return any one of these numbers.
-
-You can also combine different data types in this array and have it work in the same way. If mixed in
-strings, the result could be either one of the provided numbers or one of the provided strings.
-
-\`\`\`json
-[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "Peter", "Patrick", "Michael", "Harry"]
-\`\`\`
-`,
-    },
-    'random.integer': {
-        type: 'array',
-        maxItems: 2,
-        minItems: 2,
-        items: {
-            type: 'integer',
-        },
-        description: `Pick and return a random integer between the provided lowest and highest values.
-For example:
-\`\`\`yaml
-random.integer:
-  - 0
-  - 1000
-\`\`\`
-
-Returns a random integer between 0 and 1000.
-`,
-    },
-    'random.float': {
-        type: 'array',
-        maxItems: 2,
-        minItems: 2,
-        items: {
-            type: 'number',
-        },
-        description: `Pick and return a random float value between the provided lowest and highest values.
-For example:
-\`\`\`yaml
-random.float:
-  - 0
-  - 1
-\`\`\`
-
-Returns a random float value between 0 and 1.
-`,
-    },
-    'random.string': {
-        type: 'object',
-        required: ['choice', 'length'],
-        additionalProperties: false,
-        properties: {
-            choice: { type: 'string', minLength: 1 },
-            length: { type: 'integer', minimum: 1 },
-        },
-        description: `Pick and return a random string from a given length using characters from a given input string defined in \`choice\`.
-For example:
-\`\`\`yaml
-random.string:
-  choice: abcdefghijklmnopqrstuvwxyz0123456789
-  length: 6
-\`\`\`
-
-Returns a randomized string that is 6 characters long and consists of any characters in the \`choice\` field, like: \`g8ajss9\`.
-`,
-    },
-};
-//# sourceMappingURL=randoms.js.map

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

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