sails-vectorai 0.0.0

package/README.md

@@ -0,0 +1,65 @@
+# sails-vectorai
+
+Experimental Sails/Waterline adapter for proving the VectorAI datastore contract. It is currently developed inside PairLore and published as `sails-vectorai`.
+
+It was generated with:
+
+```sh
+npx sails generate adapter vectorai
+```
+
+Then it was narrowed into a local-first adapter inspired by `sails-sqlite`: register a datastore, keep a datastore manager, expose Waterline stage-3 methods, and keep the implementation small until the real backend contract settles.
+
+## Current DX
+
+Configure a datastore with `adapter: 'sails-vectorai'`, point models at that datastore, and use normal Waterline calls for local development:
+
+```js
+await CulturalReferenceEmbedding.createEach([
+  {
+    text: 'AI memory tool launch post',
+    embedding: [1, 0, 0],
+    topic: 'ai'
+  }
+])
+
+var matches = await CulturalReferenceEmbedding.find({
+  where: { topic: 'ai' },
+  limit: 5
+}).meta({
+  vectorSearch: {
+    column: 'embedding',
+    nearestTo: [0.98, 0.02, 0],
+    metric: 'cosine',
+    scoreField: 'similarity',
+    distanceField: 'distance'
+  }
+})
+```
+
+`meta.vectorSearch` is the adapter-specific escape hatch. It keeps the model API boring while leaving room for Actian VectorAI DB or another vector backend behind the same Waterline boundary.
+
+## Implemented Methods
+
+| Method            | Status      | Category  |
+| :---------------- | :---------- | :-------- |
+| registerDatastore | Implemented | LIFECYCLE |
+| teardown          | Implemented | LIFECYCLE |
+| create            | Implemented | DML       |
+| createEach        | Implemented | DML       |
+| update            | Implemented | DML       |
+| destroy           | Implemented | DML       |
+| find              | Implemented | DQL       |
+| count             | Implemented | DQL       |
+| sum               | Implemented | DQL       |
+| avg               | Implemented | DQL       |
+| define            | Implemented | DDL       |
+| drop              | Implemented | DDL       |
+
+## Not Yet
+
+The adapter does not implement joins, associations, persistence, connection pooling, native queries, or Actian-specific SQL yet. Those should be added only when PairLore's product loop proves the need.
+
+## License
+
+This local adapter is available under the MIT license.

package/index.js

@@ -0,0 +1,780 @@
+var _ = require('@sailshq/lodash')
+
+var registeredDatastores = {}
+
+function makeUsageError(message) {
+  var err = new Error(message)
+  err.name = 'AdapterError'
+  return err
+}
+
+function makeUniqueError(message, keys) {
+  var err = new Error(message)
+  err.code = 'E_UNIQUE'
+  err.footprint = {
+    identity: 'notUnique',
+    keys: keys || []
+  }
+  return err
+}
+
+function clone(value) {
+  return _.cloneDeep(value)
+}
+
+function normalizeModel(modelKey, modelInfo) {
+  modelInfo = modelInfo || {}
+
+  var definition = modelInfo.definition || modelInfo.attributes || {}
+  var identity = modelInfo.identity || modelKey
+  var tableName = modelInfo.tableName || identity
+
+  return {
+    identity: identity,
+    primaryKey: modelInfo.primaryKey || 'id',
+    definition: definition,
+    attributes: definition,
+    tableName: tableName
+  }
+}
+
+function registerModel(manager, modelKey, modelInfo) {
+  var model = normalizeModel(modelKey, modelInfo)
+
+  manager.modelsByIdentity[model.identity] = model
+  manager.modelsByTable[model.tableName] = model
+  ensureTable(manager, model.tableName)
+
+  return model
+}
+
+function ensureTable(manager, tableName) {
+  if (!manager.tables[tableName]) {
+    manager.tables[tableName] = []
+  }
+
+  if (!manager.sequences[tableName]) {
+    manager.sequences[tableName] = 0
+  }
+
+  return manager.tables[tableName]
+}
+
+function getDatastore(datastoreName) {
+  var dsEntry = registeredDatastores[datastoreName]
+
+  if (!dsEntry) {
+    throw makeUsageError(
+      'Consistency violation: Cannot use datastore `' +
+        datastoreName +
+        '` because it is not registered with this adapter.'
+    )
+  }
+
+  return dsEntry
+}
+
+function getModel(manager, tableName) {
+  return manager.modelsByTable[tableName] || normalizeModel(tableName, {})
+}
+
+function getPkColumn(model) {
+  var primaryKey = model.primaryKey || 'id'
+  var attrs = model.attributes || model.definition || {}
+  var pkAttr = attrs[primaryKey] || {}
+
+  return pkAttr.columnName || primaryKey
+}
+
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key)
+}
+
+function getTableForQuery(dsEntry, s3q) {
+  if (!s3q || !s3q.using) {
+    throw makeUsageError(
+      'Consistency violation: Received a stage-3 query without a `using` table name.'
+    )
+  }
+
+  return ensureTable(dsEntry.manager, s3q.using)
+}
+
+function insertRecord(manager, tableName, rawRecord) {
+  var table = ensureTable(manager, tableName)
+  var model = getModel(manager, tableName)
+  var pkColumn = getPkColumn(model)
+  var record = clone(rawRecord || {})
+
+  if (record[pkColumn] === undefined || record[pkColumn] === null) {
+    manager.sequences[tableName] += 1
+    record[pkColumn] = manager.sequences[tableName]
+  } else if (
+    _.isNumber(record[pkColumn]) &&
+    record[pkColumn] > manager.sequences[tableName]
+  ) {
+    manager.sequences[tableName] = record[pkColumn]
+  }
+
+  var hasDuplicatePk = _.some(table, function (existingRecord) {
+    return _.isEqual(existingRecord[pkColumn], record[pkColumn])
+  })
+
+  if (hasDuplicatePk) {
+    throw makeUniqueError(
+      'Cannot insert duplicate primary key value for `' + pkColumn + '`.',
+      [pkColumn]
+    )
+  }
+
+  table.push(record)
+
+  return record
+}
+
+function matchesCriteria(record, where) {
+  if (!where || _.isEmpty(where)) {
+    return true
+  }
+
+  return _.every(where, function (expected, key) {
+    if (key === 'or') {
+      return _.some(expected || [], function (subcriteria) {
+        return matchesCriteria(record, subcriteria)
+      })
+    }
+
+    if (key === 'and') {
+      return _.every(expected || [], function (subcriteria) {
+        return matchesCriteria(record, subcriteria)
+      })
+    }
+
+    return matchesValue(record[key], expected)
+  })
+}
+
+function matchesValue(actual, expected) {
+  if (_.isArray(expected)) {
+    return _.some(expected, function (candidate) {
+      return _.isEqual(actual, candidate)
+    })
+  }
+
+  if (_.isPlainObject(expected)) {
+    var operatorKeys = [
+      '<',
+      '<=',
+      '>',
+      '>=',
+      '!=',
+      'in',
+      'nin',
+      'contains',
+      'startsWith',
+      'endsWith'
+    ]
+    var isOperatorCriteria = _.some(_.keys(expected), function (key) {
+      return _.includes(operatorKeys, key)
+    })
+
+    if (!isOperatorCriteria) {
+      return _.isEqual(actual, expected)
+    }
+
+    return _.every(expected, function (operand, operator) {
+      return matchesOperator(actual, operator, operand)
+    })
+  }
+
+  return _.isEqual(actual, expected)
+}
+
+function matchesOperator(actual, operator, operand) {
+  switch (operator) {
+    case '<':
+      return actual < operand
+    case '<=':
+      return actual <= operand
+    case '>':
+      return actual > operand
+    case '>=':
+      return actual >= operand
+    case '!=':
+      if (_.isArray(operand)) {
+        return !_.some(operand, function (candidate) {
+          return _.isEqual(actual, candidate)
+        })
+      }
+      return !_.isEqual(actual, operand)
+    case 'in':
+      return _.some(operand || [], function (candidate) {
+        return _.isEqual(actual, candidate)
+      })
+    case 'nin':
+      return !_.some(operand || [], function (candidate) {
+        return _.isEqual(actual, candidate)
+      })
+    case 'contains':
+      return _.includes(String(actual || ''), String(operand))
+    case 'startsWith':
+      return String(actual || '').indexOf(String(operand)) === 0
+    case 'endsWith':
+      return (
+        String(actual || '').slice(-String(operand).length) === String(operand)
+      )
+    default:
+      return false
+  }
+}
+
+function parseSort(sort) {
+  if (!sort) {
+    return []
+  }
+
+  if (_.isString(sort)) {
+    return _.compact(sort.split(',')).map(function (sortClause) {
+      var parts = sortClause.trim().split(/\s+/)
+      return {
+        field: parts[0],
+        direction: String(parts[1] || 'ASC').toUpperCase()
+      }
+    })
+  }
+
+  if (_.isPlainObject(sort)) {
+    return _.map(sort, function (direction, field) {
+      return {
+        field: field,
+        direction: String(direction || 'ASC').toUpperCase()
+      }
+    })
+  }
+
+  if (_.isArray(sort)) {
+    return sort.reduce(function (memo, sortDirective) {
+      return memo.concat(parseSort(sortDirective))
+    }, [])
+  }
+
+  return []
+}
+
+function compareBySort(a, b, sortDirectives) {
+  for (var i = 0; i < sortDirectives.length; i += 1) {
+    var directive = sortDirectives[i]
+    var direction = directive.direction === 'DESC' ? -1 : 1
+
+    if (a[directive.field] < b[directive.field]) {
+      return -1 * direction
+    }
+
+    if (a[directive.field] > b[directive.field]) {
+      return 1 * direction
+    }
+  }
+
+  return 0
+}
+
+function applyVectorSearch(records, dsEntry, meta) {
+  var vectorSearch = meta && meta.vectorSearch
+
+  if (!vectorSearch) {
+    return records
+  }
+
+  var nearestTo =
+    vectorSearch.nearestTo || vectorSearch.queryVector || vectorSearch.vector
+  var column =
+    vectorSearch.column ||
+    vectorSearch.vectorColumn ||
+    vectorSearch.field ||
+    dsEntry.config.vectorColumn ||
+    'embedding'
+  var metric = String(vectorSearch.metric || dsEntry.config.metric || 'cosine')
+    .toLowerCase()
+    .trim()
+  var scoreField =
+    vectorSearch.scoreField === false
+      ? false
+      : vectorSearch.scoreField || 'similarity'
+  var distanceField =
+    vectorSearch.distanceField === false ? false : vectorSearch.distanceField
+
+  if (!_.isArray(nearestTo)) {
+    throw makeUsageError(
+      'Invalid `meta.vectorSearch`: expected `nearestTo` to be an array of numbers.'
+    )
+  }
+
+  return _.compact(
+    records.map(function (record) {
+      var recordVector = record[column]
+
+      if (!_.isArray(recordVector)) {
+        return undefined
+      }
+
+      var result = clone(record)
+      var match = calculateVectorMatch(recordVector, nearestTo, metric)
+
+      result.__vectorSearchScore = match.score
+
+      if (scoreField) {
+        result[scoreField] = match.similarity
+      }
+
+      if (distanceField) {
+        result[distanceField] = match.distance
+      }
+
+      return result
+    })
+  )
+}
+
+function calculateVectorMatch(recordVector, queryVector, metric) {
+  if (recordVector.length !== queryVector.length) {
+    throw makeUsageError(
+      'Invalid `meta.vectorSearch`: vector dimensions must match.'
+    )
+  }
+
+  var distance = euclideanDistance(recordVector, queryVector)
+  var similarity
+  var score
+
+  switch (metric) {
+    case 'dot':
+    case 'inner-product':
+      similarity = dotProduct(recordVector, queryVector)
+      score = similarity
+      break
+    case 'euclidean':
+    case 'l2':
+      similarity = 1 / (1 + distance)
+      score = similarity
+      break
+    case 'cosine':
+      similarity = cosineSimilarity(recordVector, queryVector)
+      score = similarity
+      break
+    default:
+      throw makeUsageError(
+        'Invalid `meta.vectorSearch.metric`: expected cosine, dot, or euclidean.'
+      )
+  }
+
+  return {
+    distance: distance,
+    similarity: similarity,
+    score: score
+  }
+}
+
+function dotProduct(a, b) {
+  return _.sum(
+    a.map(function (value, index) {
+      return value * b[index]
+    })
+  )
+}
+
+function euclideanDistance(a, b) {
+  return Math.sqrt(
+    _.sum(
+      a.map(function (value, index) {
+        return Math.pow(value - b[index], 2)
+      })
+    )
+  )
+}
+
+function cosineSimilarity(a, b) {
+  var denominator = Math.sqrt(dotProduct(a, a)) * Math.sqrt(dotProduct(b, b))
+
+  if (denominator === 0) {
+    return 0
+  }
+
+  return dotProduct(a, b) / denominator
+}
+
+function runFind(dsEntry, s3q) {
+  var table = getTableForQuery(dsEntry, s3q)
+  var criteria = s3q.criteria || {}
+  var sortDirectives = parseSort(criteria.sort)
+
+  var records = table.filter(function (record) {
+    return matchesCriteria(record, criteria.where)
+  })
+
+  records = applyVectorSearch(records, dsEntry, s3q.meta)
+
+  records.sort(function (a, b) {
+    if (
+      a.__vectorSearchScore !== undefined ||
+      b.__vectorSearchScore !== undefined
+    ) {
+      var scoreComparison =
+        (b.__vectorSearchScore || 0) - (a.__vectorSearchScore || 0)
+
+      if (scoreComparison !== 0) {
+        return scoreComparison
+      }
+    }
+
+    return compareBySort(a, b, sortDirectives)
+  })
+
+  if (criteria.skip) {
+    records = records.slice(criteria.skip)
+  }
+
+  if (_.isNumber(criteria.limit)) {
+    records = records.slice(0, criteria.limit)
+  }
+
+  return records.map(function (record) {
+    return projectRecord(record, s3q, getModel(dsEntry.manager, s3q.using))
+  })
+}
+
+function projectRecord(record, s3q, model) {
+  var criteria = s3q.criteria || {}
+  var selectedFields = criteria.select
+  var projectedRecord
+
+  if (_.isArray(selectedFields) && selectedFields.length > 0) {
+    projectedRecord = {}
+
+    selectedFields.forEach(function (fieldName) {
+      if (hasOwn(record, fieldName)) {
+        projectedRecord[fieldName] = clone(record[fieldName])
+      }
+    })
+
+    var pkColumn = getPkColumn(model)
+    if (hasOwn(record, pkColumn)) {
+      projectedRecord[pkColumn] = clone(record[pkColumn])
+    }
+
+    addVectorScoreFields(record, projectedRecord, s3q.meta)
+  } else {
+    projectedRecord = clone(record)
+  }
+
+  if (_.isArray(criteria.omit)) {
+    criteria.omit.forEach(function (fieldName) {
+      delete projectedRecord[fieldName]
+    })
+  }
+
+  delete projectedRecord.__vectorSearchScore
+
+  return projectedRecord
+}
+
+function addVectorScoreFields(source, target, meta) {
+  var vectorSearch = meta && meta.vectorSearch
+
+  if (!vectorSearch) {
+    return
+  }
+
+  var scoreField =
+    vectorSearch.scoreField === false
+      ? false
+      : vectorSearch.scoreField || 'similarity'
+  var distanceField =
+    vectorSearch.distanceField === false ? false : vectorSearch.distanceField
+
+  if (scoreField && hasOwn(source, scoreField)) {
+    target[scoreField] = clone(source[scoreField])
+  }
+
+  if (distanceField && hasOwn(source, distanceField)) {
+    target[distanceField] = clone(source[distanceField])
+  }
+}
+
+function sumRecords(records, fieldName) {
+  return records.reduce(function (total, record) {
+    return total + (Number(record[fieldName]) || 0)
+  }, 0)
+}
+
+module.exports = {
+  identity: 'sails-vectorai',
+
+  adapterApiVersion: 1,
+
+  defaults: {
+    url: 'memory://pairlore-vectorai',
+    metric: 'cosine',
+    vectorColumn: 'embedding'
+  },
+
+  datastores: registeredDatastores,
+
+  registerDatastore: function registerDatastore(dsConfig, models, done) {
+    var datastoreName = dsConfig.identity
+
+    if (!datastoreName) {
+      return done(
+        makeUsageError(
+          'Consistency violation: A datastore must contain an `identity` property.'
+        )
+      )
+    }
+
+    if (registeredDatastores[datastoreName]) {
+      return done(
+        makeUsageError(
+          'Consistency violation: Cannot register datastore `' +
+            datastoreName +
+            '` because it is already registered with this adapter.'
+        )
+      )
+    }
+
+    var manager = {
+      config: dsConfig,
+      tables: {},
+      sequences: {},
+      modelsByIdentity: {},
+      modelsByTable: {}
+    }
+
+    _.each(models || {}, function (modelInfo, modelKey) {
+      registerModel(manager, modelKey, modelInfo)
+    })
+
+    registeredDatastores[datastoreName] = {
+      config: _.defaults({}, dsConfig, module.exports.defaults),
+      manager: manager,
+      driver: undefined
+    }
+
+    return done()
+  },
+
+  teardown: function teardown(datastoreName, done) {
+    if (!datastoreName) {
+      return done(
+        makeUsageError(
+          'Consistency violation: Cannot tear down a datastore without a datastore name.'
+        )
+      )
+    }
+
+    if (!registeredDatastores[datastoreName]) {
+      return done(
+        makeUsageError(
+          'Consistency violation: Cannot tear down datastore `' +
+            datastoreName +
+            '` because it is not registered with this adapter.'
+        )
+      )
+    }
+
+    delete registeredDatastores[datastoreName]
+    return done()
+  },
+
+  create: function create(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      var record = insertRecord(dsEntry.manager, s3q.using, s3q.newRecord)
+
+      return done(null, s3q.meta && s3q.meta.fetch ? clone(record) : undefined)
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  createEach: function createEach(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      var records = (s3q.newRecords || []).map(function (newRecord) {
+        return insertRecord(dsEntry.manager, s3q.using, newRecord)
+      })
+
+      return done(
+        null,
+        s3q.meta && s3q.meta.fetch ? records.map(clone) : undefined
+      )
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  update: function update(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      var table = getTableForQuery(dsEntry, s3q)
+      var criteria = s3q.criteria || {}
+      var valuesToSet = s3q.valuesToSet || {}
+      var model = getModel(dsEntry.manager, s3q.using)
+      var pkColumn = getPkColumn(model)
+      var matchingRecords = table.filter(function (record) {
+        return matchesCriteria(record, criteria.where)
+      })
+
+      if (hasOwn(valuesToSet, pkColumn)) {
+        if (matchingRecords.length > 1) {
+          throw makeUniqueError(
+            'Cannot update multiple records to the same primary key value for `' +
+              pkColumn +
+              '`.',
+            [pkColumn]
+          )
+        }
+
+        var duplicatePk = _.some(table, function (record) {
+          return (
+            !_.includes(matchingRecords, record) &&
+            _.isEqual(record[pkColumn], valuesToSet[pkColumn])
+          )
+        })
+
+        if (duplicatePk) {
+          throw makeUniqueError(
+            'Cannot update duplicate primary key value for `' + pkColumn + '`.',
+            [pkColumn]
+          )
+        }
+      }
+
+      matchingRecords.forEach(function (record) {
+        _.assign(record, clone(valuesToSet))
+      })
+
+      return done(
+        null,
+        s3q.meta && s3q.meta.fetch ? matchingRecords.map(clone) : undefined
+      )
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  destroy: function destroy(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      var table = getTableForQuery(dsEntry, s3q)
+      var criteria = s3q.criteria || {}
+      var destroyedRecords = []
+
+      for (var i = table.length - 1; i >= 0; i -= 1) {
+        if (matchesCriteria(table[i], criteria.where)) {
+          destroyedRecords.unshift(table[i])
+          table.splice(i, 1)
+        }
+      }
+
+      return done(
+        null,
+        s3q.meta && s3q.meta.fetch ? destroyedRecords.map(clone) : undefined
+      )
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  find: function find(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      return done(null, runFind(dsEntry, s3q))
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  count: function count(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      var table = getTableForQuery(dsEntry, s3q)
+      var criteria = s3q.criteria || {}
+      var total = table.filter(function (record) {
+        return matchesCriteria(record, criteria.where)
+      }).length
+
+      return done(null, total)
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  sum: function sum(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      var records = runFind(dsEntry, _.assign({}, s3q, { meta: undefined }))
+
+      return done(null, sumRecords(records, s3q.numericAttrName))
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  avg: function avg(datastoreName, s3q, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      var records = runFind(dsEntry, _.assign({}, s3q, { meta: undefined }))
+
+      if (records.length === 0) {
+        return done(null, 0)
+      }
+
+      return done(
+        null,
+        sumRecords(records, s3q.numericAttrName) / records.length
+      )
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  define: function define(datastoreName, tableName, definition, done) {
+    try {
+      var dsEntry = getDatastore(datastoreName)
+      ensureTable(dsEntry.manager, tableName)
+      registerModel(dsEntry.manager, tableName, {
+        identity: tableName,
+        primaryKey: 'id',
+        tableName: tableName,
+        definition: definition
+      })
+
+      return done()
+    } catch (err) {
+      return done(err)
+    }
+  },
+
+  drop: function drop(datastoreName, tableName, relations, done) {
+    if (_.isFunction(relations)) {
+      done = relations
+    }
+
+    try {
+      var dsEntry = getDatastore(datastoreName)
+
+      delete dsEntry.manager.tables[tableName]
+      delete dsEntry.manager.sequences[tableName]
+      delete dsEntry.manager.modelsByTable[tableName]
+
+      _.each(dsEntry.manager.modelsByIdentity, function (model, identity) {
+        if (model.tableName === tableName) {
+          delete dsEntry.manager.modelsByIdentity[identity]
+        }
+      })
+
+      return done()
+    } catch (err) {
+      return done(err)
+    }
+  }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "sails-vectorai",
+  "version": "0.0.0",
+  "description": "Experimental Sails/Waterline adapter for VectorAI.",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test/run-standard-tests",
+    "pretest": "npm run lint",
+    "lint": "node ./node_modules/eslint/bin/eslint . --max-warnings=0"
+  },
+  "keywords": [
+    "actian",
+    "vector",
+    "vectorai",
+    "vector-database",
+    "semantic-search",
+    "adapter",
+    "sails",
+    "sails.js",
+    "waterline",
+    "orm",
+    "database-adapter"
+  ],
+  "author": "Sailscasts HQ",
+  "license": "MIT",
+  "dependencies": {
+    "@sailshq/lodash": "^3.10.2"
+  },
+  "devDependencies": {
+    "eslint": "3.19.0",
+    "waterline-adapter-tests": "^1.0.0-6"
+  },
+  "waterlineAdapter": {
+    "type": "vectorai",
+    "waterlineVersion": "~0.13.0",
+    "interfaces": [
+      "semantic",
+      "queryable",
+      "migratable"
+    ],
+    "features": []
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "test"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sailscastshq/pairlore.git",
+    "directory": "api/adapters/vectorai"
+  },
+  "bugs": {
+    "url": "https://github.com/sailscastshq/pairlore/issues"
+  },
+  "homepage": "https://github.com/sailscastshq/pairlore/tree/main/api/adapters/vectorai#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/test/run-standard-tests.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Module dependencies
+ */
+
+var TestRunner = require('waterline-adapter-tests')
+var packageMD = require('../package.json')
+var Adapter = require('../')
+
+// Log an intro message.
+console.log('Testing `' + packageMD.name + '`, a Sails/Waterline adapter.')
+console.log(
+  'Running `waterline-adapter-tests` against ' +
+    packageMD.waterlineAdapter.interfaces.length +
+    ' interface(s) and ' +
+    packageMD.waterlineAdapter.features.length +
+    ' feature(s)...'
+)
+console.log(
+  '|   Interfaces:       ' +
+    (packageMD.waterlineAdapter.interfaces.join(', ') || 'n/a') +
+    ''
+)
+console.log(
+  '|   Extra features:   ' +
+    (packageMD.waterlineAdapter.features.join(', ') || 'n/a') +
+    ''
+)
+console.log()
+console.log('> More info about building Waterline adapters:')
+console.log(
+  '> https://sailsjs.com/docs/concepts/extending-sails/adapters/custom-adapters'
+)
+
+// Ensure a `url` was specified.
+// (https://sailsjs.com/config/datastores#?the-connection-url)
+if (!process.env.WATERLINE_ADAPTER_TESTS_URL) {
+  console.error()
+  console.error('-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-')
+  console.error('Cannot run tests: No database connection `url` specified.')
+  console.error()
+  console.error('Tip: You can use an environment variable to configure this.')
+  console.error('For example:')
+  console.error('```')
+  console.error(
+    '    WATERLINE_ADAPTER_TESTS_URL=root@localhost:3306/testdb npm test'
+  )
+  console.error('```')
+  console.error('-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-')
+  process.exit(1)
+} //-•
+
+// Use the `waterline-adapter-tests` module to
+// run mocha tests against the specified interfaces
+// of the currently-implemented Waterline adapter API.
+new TestRunner({
+  // Load the adapter module.
+  adapter: Adapter,
+
+  // Adapter config to use for tests.
+  config: {
+    url: process.env.WATERLINE_ADAPTER_TESTS_URL
+  },
+
+  // The set of adapter interface layers & specific features to test against.
+  interfaces: packageMD.waterlineAdapter.interfaces,
+  features: packageMD.waterlineAdapter.features
+})
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//
+// Most databases implement 'semantic' and 'queryable' interface layers.
+//
+// For full interface reference, see:
+// https://sailsjs.com/docs/concepts/extending-sails/adapters/custom-adapters
+//
+// Some features are polyfilled if omitted; allowing optimizations at the adapter
+// level for databases that support the feature.  For example, if you don't implement
+// a `join` method, it will be polyfilled for you by Waterline core (using the same
+// "polypopulate" that it uses for cross-datastore joins.)  For more on that, talk
+// to an adapter maintainer @ https://sailsjs.com/support.
+//
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -