seatsio 72.3.0 → 72.6.0

package/.github/workflows/release.yml

@@ -0,0 +1,42 @@
+# Very important!
+# Make sure that the github token has read AND WRITE access on github.
+#   1. hit https://github.com/seatsio/[REPO]/settings/actions
+#   2. under "Workflow permissions", make sure "Read and write permissions" is checked instead of the (default?) read only.
+#
+
+name: Release
+run-name: Release ${{ github.repository }}
+on:
+  workflow_dispatch:
+    inputs:
+      versionToBump:
+        description: 'The version to bump. Major for incompatible API changes, minor for adding BC features'
+        required: true
+        type: choice
+        options:
+          - minor
+          - major
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: fregante/setup-git-user@v2
+      - id: install-zx
+        run: npm i -g zx
+      - id: install-semver-tool
+        run: |
+          wget -O /usr/local/bin/semver https://raw.githubusercontent.com/fsaintjacques/semver-tool/master/src/semver
+          chmod +x /usr/local/bin/semver
+      - run: zx ./release.mjs -v $VERSION_TO_BUMP
+        env:
+          VERSION_TO_BUMP: ${{ inputs.versionToBump }}
+          GH_TOKEN: ${{ github.token }}
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 18
+          registry-url: https://registry.npmjs.org/
+      - run: yarn install
+      - run: yarn publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/README.md

@@ -56,6 +56,19 @@ let event = await client.events.create(chart.key)
 console.log(`Created a chart with key ${chart.key} and an event with key: ${event.key}`)
 ```
 
+### Creating multiple events
+
+```js
+import { SeatsioClient, Region, Events } from 'seatsio'
+
+let client = new SeatsioClient(Region.EU(), <WORKSPACE SECRET KEY>)
+let chart = await client.charts.create()
+let events = await client.events.createMultiple(chart.key, [ Events.eventCreationParams(), Events.eventCreationParams('aSpecificEventKey') ])
+for (const event of events) {
+    console.log(`Created an event with key: ${event.key}`)
+}
+```
+
 ### Booking objects
 
 Booking an object changes its status to `booked`. Booked seats are not selectable on a rendered chart.
@@ -256,6 +269,18 @@ let event = await client.events.create(chart.key)
 console.log(`Created a chart with key ${chart.key} and an event with key: ${event.key}`)
 ```
 
+### Listing categories
+
+```js
+import { SeatsioClient, Region } from 'seatsio'
+
+let client = new SeatsioClient(Region.EU(), <COMPANY ADMIN KEY>, <WORKSPACE PUBLIC KEY>)
+let categories = await client.charts.listCategories("the chart key")
+for (const category of categoryList) {
+    console.log(category.label)
+}
+```
+
 ## Error Handling
 When an API call results in an error, a rejected promise is returned with a value that looks like
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seatsio",
-  "version": "72.3.0",
+  "version": "72.6.0",
   "main": "index.js",
   "description": "Official JavaScript and Node.JS client library for the Seats.io REST API",
   "license": "MIT",
@@ -13,16 +13,16 @@
     "url": "https://github.com/seatsio/seatsio-js"
   },
   "dependencies": {
-    "axios": "1.3.0"
+    "axios": "1.3.4"
   },
   "devDependencies": {
-    "eslint": "8.33.0",
+    "eslint": "8.35.0",
     "eslint-config-standard": "17.0.0",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-n": "15.6.1",
     "eslint-plugin-promise": "6.1.1",
-    "jest": "29.4.1",
-    "jest-cli": "29.4.1",
+    "jest": "29.4.3",
+    "jest-cli": "29.4.3",
     "uuid": "9.0.0"
   }
 }

package/release.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env zx
+
+/*
+* Script to release the seats.io java lib.
+*   - changes the version number in README.md
+*   - changes the version number in build.gradle
+*   - creates the release in Gihub (using gh cli)
+*
+*
+* Prerequisites:
+*   - zx installed (https://github.com/google/zx)
+*   - gh cli installed (https://cli.github.com/)
+*   - semver cli installed (https://github.com/fsaintjacques/semver-tool)
+*
+* Usage:
+*   zx ./release.mjs -v major/minor -n "release notes"
+* */
+
+// don't output the commands themselves
+$.verbose = false
+
+const versionToBump = getVersionToBump()
+const latestVersion = await fetchLatestReleasedVersionNumber()
+const nextVersion = await determineNextVersionNumber(latestVersion)
+
+await pullLastVersion()
+    .then(bumpVersionInFiles)
+    .then(commitAndPush)
+    .then(release)
+
+function getVersionToBump() {
+    if (!argv.v || !(argv.v === 'minor' || argv.v === 'major')) {
+        throw new Error ("Please specify -v major/minor")
+    }
+    return argv.v
+}
+
+function removeLeadingV(tagName) {
+    if (tagName.startsWith('v')) {
+        return tagName.substring(1)
+    }
+    return tagName
+}
+
+async function fetchLatestReleasedVersionNumber() {
+    let result = await $`gh release view --json tagName`
+    let tagName = JSON.parse(result).tagName
+    return removeLeadingV(tagName)
+}
+
+async function determineNextVersionNumber(previous) {
+    return (await $`semver bump ${versionToBump} ${previous}`).stdout.trim()
+}
+
+async function bumpVersionInFiles() {
+    await replaceInFile("package.json", `"version": "${latestVersion}",`, `"version": "${nextVersion}",`)
+}
+
+async function replaceInFile(filename, latestVersion, nextVersion) {
+    return await fs.readFile(filename, 'utf8')
+        .then(text => {
+            if (text.indexOf(latestVersion) < 0) {
+                throw new Error('Not the correct version. Could not find ' + latestVersion + ' in ' + filename)
+            }
+            return text
+        })
+        .then(text => text.replace(latestVersion, nextVersion))
+        .then(text => fs.writeFileSync(filename, text))
+        .then(() => gitAdd(filename))
+}
+
+async function pullLastVersion() {
+    await $`git checkout master`
+    await $`git pull origin master`
+}
+
+async function gitAdd(filename) {
+    return await $`git add ${filename}`
+}
+
+async function commitAndPush() {
+    await $`git commit -m "version bump"`
+    await $`git push origin master`
+}
+
+async function release() {
+    const newTag = 'v' + nextVersion
+    return await $`gh release create ${newTag} --generate-notes`.catch(error => {
+        console.error('something went wrong while creating the release. Please revert the version change!')
+        throw error
+    })
+}

package/src/Charts/Charts.js

@@ -68,6 +68,11 @@ class Charts {
         return this.client.delete(`/charts/${chartKey}/categories/${categoryKey}`)
     }
 
+    listCategories (key) {
+        return this.client.get(`/charts/${key}/categories`)
+            .then((res) => res.data.categories)
+    }
+
     /**
      * @param {string} key
      * @returns {object}

package/src/Events/Events.js

@@ -16,7 +16,6 @@ class Events {
         this.channels = new Channels(this.client)
     }
 
-    /* @return Event */
     /**
      * @param {string} chartKey
      * @param {?string} eventKey
@@ -55,6 +54,73 @@ class Events {
             .then((res) => new EventDeserializer().fromJson(res.data))
     }
 
+    /**
+     * @param {?string} eventKey
+     * @param {?TableBookingConfig} tableBookingConfig
+     * @param {?string} socialDistancingRulesetKey
+     * @param {?object} objectCategories
+     * @param {?array} categories
+     * @returns an object containing the necessary data for event creation
+     * @static
+     */
+    static eventCreationParams (eventKey = null, tableBookingConfig = null, socialDistancingRulesetKey = null, objectCategories = null, categories = null) {
+        const eventDefinition = {}
+        eventDefinition.eventKey = eventKey
+        eventDefinition.tableBookingConfig = tableBookingConfig
+        eventDefinition.socialDistancingRulesetKey = socialDistancingRulesetKey
+        eventDefinition.objectCategories = objectCategories
+        eventDefinition.categories = categories
+        return eventDefinition
+    }
+
+    /**
+     * @param {string} chartKey
+     * @param {object[]} events use {@link Events.eventCreationParams()} as a convenience function to create these objects
+     * @returns {Promise<Event[]>}
+     */
+    createMultiple (chartKey, events) {
+        const requestParameters = {}
+
+        requestParameters.chartKey = chartKey
+        requestParameters.events = []
+
+        if (events) {
+            for (let i = 0; i < events.length; i++) {
+                const event = {}
+                if (events[i].eventKey !== null) {
+                    event.eventKey = events[i].eventKey
+                }
+
+                if (events[i].tableBookingConfig !== null) {
+                    event.tableBookingConfig = events[i].tableBookingConfig
+                }
+
+                if (events[i].socialDistancingRulesetKey !== null) {
+                    event.socialDistancingRulesetKey = events[i].socialDistancingRulesetKey
+                }
+
+                if (events[i].objectCategories !== null) {
+                    event.objectCategories = events[i].objectCategories
+                }
+
+                if (events[i].categories != null) {
+                    event.categories = events[i].categories
+                }
+                requestParameters.events.push(event)
+            }
+        }
+
+        return this.client.post('/events/actions/create-multiple', requestParameters)
+            .then((res) => {
+                const result = []
+                const deserializer = new EventDeserializer()
+                for (const event of res.data.events) {
+                    result.push(deserializer.fromJson(event))
+                }
+                return result
+            })
+    }
+
     /**
      * @param {string} eventKey
      * @returns {Promise<Event>}

package/tests/charts/manageCategories.test.js

@@ -30,3 +30,15 @@ test('should remove a category', async () => {
     const retrievedChart = await client.charts.retrievePublishedVersion(chart.key)
     expect(retrievedChart.categories.list).toEqual([{ key: 1, label: 'Category 1', color: '#aaaaaa', accessible: false }])
 })
+
+test('should retrieve the categories of a chart', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const categories = [
+        { key: 1, label: 'Category 1', color: '#aaaaaa', accessible: false },
+        { key: 'cat2', label: 'Category 2', color: '#bbbbbb', accessible: true }
+    ]
+    const chart = await client.charts.create('aChart', null, categories)
+
+    const categoryList = await client.charts.listCategories(chart.key)
+    expect(categoryList).toEqual(categories)
+})

package/tests/events/createEvents.test.js

@@ -0,0 +1,134 @@
+const testUtils = require('../testUtils.js')
+const SocialDistancingRuleset = require('../../src/Charts/SocialDistancingRuleset.js')
+const TableBookingConfig = require('../../src/Events/TableBookingConfig')
+const Category = require('../../src/Charts/Category')
+const Events = require('../../src/Events/Events')
+
+test('should check that a minimum of one event is required', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    try {
+        await client.events.createMultiple(chartKey)
+    } catch (e) {
+        expect(e.errors.length).toEqual(1)
+        expect(e.errors[0].code).toBe('GENERAL_ERROR')
+        expect(e.errors[0].message).toBe('#/events: expected minimum item count: 1, found: 0')
+    }
+})
+
+test('should check that an empty object is a valid event definition', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    const events = await client.events.createMultiple(chartKey, [{}])
+
+    expect(events).toHaveLength(1)
+    expect(events[0].key).toBeTruthy()
+})
+
+test('should create a single event', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+
+    const events = await client.events.createMultiple(chart.key, [
+        Events.eventCreationParams('eventKey')
+    ])
+
+    expect(events).toHaveLength(1)
+    expect(events[0].key).toEqual('eventKey')
+
+    const retrievedEvent = await client.events.retrieve('eventKey')
+    expect(retrievedEvent.key).toEqual('eventKey')
+})
+
+test('should create multiple events', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+
+    const events = [
+        Events.eventCreationParams('eventKey1'),
+        Events.eventCreationParams('eventKey2')
+    ]
+    const createdEvents = await client.events.createMultiple(chart.key, events)
+
+    expect(createdEvents).toHaveLength(2)
+    expect(createdEvents[0].key).toEqual('eventKey1')
+    expect(createdEvents[1].key).toEqual('eventKey2')
+
+    for (const event of events) {
+        const retrievedEvent = await client.events.retrieve(event.eventKey)
+        expect(retrievedEvent.key).toEqual(event.eventKey)
+    }
+})
+
+test('supports tableBookingConfig custom', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChartWithTables(chartKey, user.secretKey)
+    const tableBookingConfig = TableBookingConfig.custom({ T1: 'BY_TABLE', T2: 'BY_SEAT' })
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, tableBookingConfig)
+    ])
+
+    expect(events[0].key).toBeTruthy()
+    expect(events[0].tableBookingConfig).toEqual(tableBookingConfig)
+})
+
+test('supports tableBookingConfig inherit', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChartWithTables(chartKey, user.secretKey)
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, TableBookingConfig.inherit())
+    ])
+
+    expect(events[0].key).toBeTruthy()
+    expect(events[0].tableBookingConfig).toEqual(TableBookingConfig.inherit())
+})
+
+test('it supports a social distancing ruleset key', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const rulesets = { ruleset1: SocialDistancingRuleset.ruleBased('My ruleset').build() }
+    await client.charts.saveSocialDistancingRulesets(chart.key, rulesets)
+
+    const events = await client.events.createMultiple(chart.key, [
+        Events.eventCreationParams(null, null, 'ruleset1')
+    ])
+
+    expect(events[0].socialDistancingRulesetKey).toBe('ruleset1')
+})
+
+test('it supports object categories', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, null, null, { 'A-1': 10 })
+    ])
+
+    expect(events[0].objectCategories).toEqual({ 'A-1': 10 })
+})
+
+test('it supports categories', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    const eventCategory = new Category('eventCat1', 'Event Level Category', '#AAABBB')
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, null, null, null, [eventCategory])
+    ])
+
+    expect(events[0].categories.length).toEqual(4) // 3 from sampleChart.json, 1 event level category
+    expect(events[0].categories.filter(cat => cat.key === 'eventCat1').length).toEqual(1)
+    expect(events[0].categories.filter(cat => cat.key === 'eventCat1')[0].label).toEqual('Event Level Category')
+    expect(events[0].categories.filter(cat => cat.key === 'eventCat1')[0].color).toEqual('#AAABBB')
+})

package/tests/subaccounts/filterSubaccounts.test.js

@@ -21,13 +21,13 @@ test('should filter subaccounts ', async () => {
 test('should filter subaccounts with special characters', async () => {
     const { client } = await testUtils.createTestUserAndClient()
     let i = 0
-    await testUtils.createArray(20, () => client.subaccounts.create('test-/@/' + i++))
+    await testUtils.createArray(10, () => client.subaccounts.create('test-/@/' + i++))
     const retrievedSubaccountKeys = []
     for await (const subaccount of client.subaccounts.listAll('test-/@/1')) {
         retrievedSubaccountKeys.push(subaccount.secretKey)
     }
 
-    expect(retrievedSubaccountKeys.length).toEqual(11)
+    expect(retrievedSubaccountKeys.length).toEqual(1)
 })
 
 test('should filter with no results ', async () => {

package/tests/testUtils.js

@@ -81,14 +81,14 @@ module.exports = {
         return uuidv4() + '@mailinator.com'
     },
 
-    createArray (length, fn) {
+    async createArray (length, fn) {
         const array = []
 
         for (let i = 0; i < length; ++i) {
-            array.push(fn())
+            array.push(await fn())
         }
 
-        return Promise.all(array)
+        return array
     },
 
     deferred () {

package/.github/workflows/publish.yml

@@ -1,19 +0,0 @@
-name: 'Publish release'
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 18
-          registry-url: https://registry.npmjs.org/
-      - run: yarn install
-      - run: yarn publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/releasing.md

@@ -1,4 +0,0 @@
-*Note: this is internal documentation for the seats.io team*
-
-1) Set the correct version number in package.json
-2) Create the release in GitHub