@evanp/activitypub-bot 0.18.0 → 0.20.0

package/README.md

@@ -332,7 +332,11 @@ PRs accepted.
 
 JavaScript code should use [JavaScript Standard Style](https://standardjs.com).
 
-There is a test suite using the Node [test runner](https://nodejs.org/api/test.html#test-runner). If you add a new feature, add tests for it. If you find a bug and fix it, add a test to make sure it stays fixed.
+There is a test suite using the Node [test runner](https://nodejs.org/api/test.html#test-runner). Run `npm run test` to start the tests. You can run just one test
+by adding it to the command-line, like `npm run test -- tests/botcontext.test.js`. The tests use `TEST_DATABASE_URL` for database configuration and default to `sqlite::memory:` (SQLite in-memory) when it is unset. This lets you test against Postgres or MySQL when needed. NOTE that the tests are destructive af and you should
+not use your production database as a unit test DB!
+
+If you add a new feature, add tests for it. If you find a bug and fix it, add a test to make sure it stays fixed.
 
 If editing the Readme, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
 

package/lib/actorstorage.js

@@ -315,7 +315,7 @@ export class ActorStorage {
       `
         INSERT INTO lastactivity (username, type, object_id, activity_id)
         VALUES (?, ?, ?, ?)
-        ON CONFLICT DO UPDATE
+        ON CONFLICT (username, type, object_id) DO UPDATE
         SET activity_id = EXCLUDED.activity_id,
             updatedAt = CURRENT_TIMESTAMP
       `,
@@ -332,14 +332,23 @@ export class ActorStorage {
 
   async #getCollectionInfo (username, property) {
     const [result] = await this.#connection.query(
-      `SELECT first, totalItems, createdAt, updatedAt
+      `SELECT
+        first,
+        totalItems AS totalitems,
+        createdAt AS createdat,
+        updatedAt AS updatedat
       FROM actorcollection
       WHERE username = ? AND property = ?;`,
       { replacements: [username, property] }
     )
     if (result.length > 0) {
       const row = result[0]
-      return [row.totalItems, row.first, row.createdAt, row.updatedAt]
+      return [
+        row.totalitems,
+        row.first,
+        row.createdat,
+        row.updatedat
+      ]
     } else {
       return [0, 1, null, null]
     }

package/lib/botdatastorage.js

@@ -27,7 +27,8 @@ export class BotDataStorage {
     assert.equal(typeof key, 'string', 'key must be a string')
     await this.#connection.query(`
       INSERT INTO botdata (value, username, key) VALUES (?, ?, ?)
-      ON CONFLICT DO UPDATE SET value = EXCLUDED.value, updatedAt = CURRENT_TIMESTAMP`,
+      ON CONFLICT (username, key) DO UPDATE
+      SET value = EXCLUDED.value, updatedAt = CURRENT_TIMESTAMP`,
     { replacements: [JSON.stringify(value), username, key] }
     )
   }

package/lib/index.js

@@ -3,3 +3,5 @@ export { default as Bot } from './bot.js'
 export { default as BotFactory } from './botfactory.js'
 export { default as OKBot } from './bots/ok.js'
 export { default as DoNothingBot } from './bots/donothing.js'
+export { default as RelayClientBot } from './bots/relayclient.js'
+export { default as RelayServerBot } from './bots/relayserver.js'

package/lib/migrations/001-initial.js

@@ -1,63 +1,65 @@
 export const id = '001-initial'
 
-export async function up (connection) {
+export async function up (connection, queryOptions = {}) {
   await connection.query(`
     CREATE TABLE IF NOT EXISTS actorcollection (
       username varchar(512) NOT NULL,
       property varchar(512) NOT NULL,
       first INTEGER NOT NULL,
       totalItems INTEGER NOT NULL DEFAULT 0,
-      createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-      updatedAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updatedAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
       PRIMARY KEY (username, property)
     );
-  `)
+  `, queryOptions)
   await connection.query(`
     CREATE TABLE IF NOT EXISTS actorcollectionpage (
       username varchar(512) NOT NULL,
       property varchar(512) NOT NULL,
       item varchar(512) NOT NULL,
       page INTEGER NOT NULL,
-      createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
       PRIMARY KEY (username, property, item)
     );
-  `)
+  `, queryOptions)
   await connection.query(
     `CREATE INDEX IF NOT EXISTS actorcollectionpage_username_property_page
-    ON actorcollectionpage (username, property, page);`
+    ON actorcollectionpage (username, property, page);`,
+    queryOptions
   )
 
   await connection.query(`
     CREATE TABLE IF NOT EXISTS objects (
       id VARCHAR(512) PRIMARY KEY,
       data TEXT NOT NULL,
-      createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-      updatedAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updatedAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
     )
-  `)
+  `, queryOptions)
   await connection.query(`
     CREATE TABLE IF NOT EXISTS collections (
       id VARCHAR(512) NOT NULL,
       property VARCHAR(512) NOT NULL,
       first INTEGER NOT NULL,
-      createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-      updatedAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updatedAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
       PRIMARY KEY (id, property)
     )
-  `)
+  `, queryOptions)
   await connection.query(`
     CREATE TABLE IF NOT EXISTS pages (
       id VARCHAR(512) NOT NULL,
       property VARCHAR(64) NOT NULL,
       item VARCHAR(512) NOT NULL,
       page INTEGER NOT NULL,
-      createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
       PRIMARY KEY (id, property, item)
     )
-  `)
+  `, queryOptions)
   await connection.query(
     `CREATE INDEX IF NOT EXISTS pages_username_property_page
-    ON pages (id, property, page);`
+    ON pages (id, property, page);`,
+    queryOptions
   )
 
   await connection.query(`
@@ -65,11 +67,11 @@ export async function up (connection) {
       username VARCHAR(512) not null,
       key VARCHAR(512) not null,
       value TEXT not null,
-      createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-      updatedAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updatedAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
       PRIMARY KEY (username, key)
     )
-  `)
+  `, queryOptions)
 
   await connection.query(`
     CREATE TABLE IF NOT EXISTS new_keys (
@@ -77,14 +79,14 @@ export async function up (connection) {
       public_key TEXT,
       private_key TEXT
     )
-  `)
-  try {
+  `, queryOptions)
+  if (await hasTable(connection, 'keys', queryOptions)) {
     await connection.query(`
-      INSERT OR IGNORE INTO new_keys (username, public_key, private_key)
+      INSERT INTO new_keys (username, public_key, private_key)
       SELECT bot_id, public_key, private_key
       FROM keys
-    `)
-  } catch {
+      ON CONFLICT DO NOTHING
+    `, queryOptions)
   }
 
   await connection.query(`
@@ -95,13 +97,38 @@ export async function up (connection) {
       createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       updatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     )
-  `)
-  try {
+  `, queryOptions)
+  if (await hasTable(connection, 'remotekeys', queryOptions)) {
     await connection.query(`
-      INSERT OR IGNORE INTO new_remotekeys (id, owner, publicKeyPem)
+      INSERT INTO new_remotekeys (id, owner, publicKeyPem)
       SELECT id, owner, publicKeyPem
       FROM remotekeys
-    `)
-  } catch {
+      ON CONFLICT DO NOTHING
+    `, queryOptions)
   }
 }
+
+function normalizeTableName (table) {
+  if (typeof table === 'string') {
+    return table
+      .split('.')
+      .pop()
+      .replaceAll('"', '')
+      .toLowerCase()
+  }
+  if (table && typeof table === 'object') {
+    if (typeof table.tableName === 'string') {
+      return table.tableName.toLowerCase()
+    }
+    if (typeof table.name === 'string') {
+      return table.name.toLowerCase()
+    }
+  }
+  return ''
+}
+
+async function hasTable (connection, tableName, queryOptions = {}) {
+  const tables = await connection.getQueryInterface().showAllTables(queryOptions)
+  const normalized = tableName.toLowerCase()
+  return tables.some((table) => normalizeTableName(table) === normalized)
+}

package/lib/migrations/002-last-activity.js

@@ -1,15 +1,15 @@
 export const id = '002-last-activity'
 
-export async function up (connection) {
+export async function up (connection, queryOptions = {}) {
   await connection.query(`
-    CREATE TABLE lastactivity (
+    CREATE TABLE IF NOT EXISTS lastactivity (
       username varchar(512) NOT NULL,
       type varchar(512) NOT NULL,
       object_id varchar(512) NOT NULL,
       activity_id varchar(512),
-      createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-      updatedAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      createdAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      updatedAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
       PRIMARY KEY (username, type, object_id)
     );
-  `)
+  `, queryOptions)
 }

package/lib/migrations/index.js

@@ -6,25 +6,39 @@ const migrations = [
   { id: lastId, up: lastUp }
 ]
 
-export async function runMigrations (connection) {
+async function runMigrationsInternal (connection, queryOptions = {}) {
   await connection.query(`
     CREATE TABLE IF NOT EXISTS migrations (
       id VARCHAR(255) PRIMARY KEY,
-      ranAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      ranAt TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
     )
-  `)
+  `, queryOptions)
 
-  const [rows] = await connection.query('SELECT id FROM migrations')
+  const [rows] = await connection.query('SELECT id FROM migrations', queryOptions)
   const applied = new Set(rows.map((row) => row.id))
 
   for (const migration of migrations) {
     if (applied.has(migration.id)) {
       continue
     }
-    await migration.up(connection)
+    await migration.up(connection, queryOptions)
     await connection.query(
-      'INSERT INTO migrations (id) VALUES (?)',
-      { replacements: [migration.id] }
+      'INSERT INTO migrations (id) VALUES (?) ON CONFLICT (id) DO NOTHING',
+      { ...queryOptions, replacements: [migration.id] }
     )
   }
 }
+
+export async function runMigrations (connection) {
+  if (connection.getDialect() === 'postgres') {
+    await connection.transaction(async (transaction) => {
+      await connection.query(
+        'SELECT pg_advisory_xact_lock(1600846134, 804024271)',
+        { transaction }
+      )
+      await runMigrationsInternal(connection, { transaction })
+    })
+  } else {
+    await runMigrationsInternal(connection)
+  }
+}

package/lib/objectstorage.js

@@ -77,19 +77,19 @@ export class ObjectStorage {
     let first = 1
     let createdAt = null
     const row = await this.#connection.query(
-      'SELECT first, createdAt FROM collections WHERE id = ? AND property = ?',
+      'SELECT first, createdAt AS createdat FROM collections WHERE id = ? AND property = ?',
       { replacements: [id, property] }
     )
     if (row[0].length > 0) {
       first = row[0][0].first
-      createdAt = row[0][0].createdAt
+      createdAt = row[0][0].createdat
     }
     const count = await this.#connection.query(
-      'SELECT COUNT(*) FROM pages WHERE id = ? AND property = ?',
+      'SELECT COUNT(*) AS count FROM pages WHERE id = ? AND property = ?',
       { replacements: [id, property] }
     )
     if (count[0].length > 0) {
-      totalItems = count[0][0]['COUNT(*)']
+      totalItems = Number(count[0][0].count ?? 0)
     }
     assert.equal(typeof totalItems, 'number', 'totalItems must be a number')
     assert.ok(totalItems >= 0, 'totalItems must be greater than or equal to 0')
@@ -223,10 +223,10 @@ export class ObjectStorage {
     assert.equal(typeof page, 'number', 'page must be a number')
     assert.ok(page >= 1, 'page must be greater than or equal to 1')
     const rows = await this.#connection.query(
-      'SELECT COUNT(*) FROM pages WHERE id = ? AND property = ? AND page = ?',
+      'SELECT COUNT(*) AS count FROM pages WHERE id = ? AND property = ? AND page = ?',
       { replacements: [id, property, page] }
     )
-    return rows[0][0]['COUNT(*)']
+    return Number(rows[0][0].count ?? 0)
   }
 
   async removeFromCollection (id, property, object) {

package/lib/remotekeystorage.js

@@ -34,13 +34,13 @@ export class RemoteKeyStorage {
   async #getCachedPublicKey (id) {
     this.debug(`#getCachedPublicKey(${id})`)
     const [result] = await this.#connection.query(
-      'SELECT publicKeyPem, owner FROM new_remotekeys WHERE id = ?',
+      'SELECT publicKeyPem AS publickeypem, owner FROM new_remotekeys WHERE id = ?',
       { replacements: [id] }
     )
     if (result.length > 0) {
       this.debug(`cache hit for ${id}`)
       return {
-        publicKeyPem: result[0].publicKeyPem,
+        publicKeyPem: result[0].publickeypem,
         owner: result[0].owner
       }
     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evanp/activitypub-bot",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "server-side ActivityPub bot framework",
   "type": "module",
   "main": "lib/index.js",