Bai 1111 allow semver matching and latest semver for releases

backend/package.json

@@ -88,6 +88,7 @@
     "@types/mjml": "^4.7.4",
     "@types/mongoose-delete": "^1.0.6",
     "@types/morgan": "^1.9.9",
+    "@types/semver": "^7.5.8",
     "@types/node": "^22.7.5",
     "@types/nodemailer": "^6.4.16",
     "@types/shelljs": "^0.8.15",

backend/src/migrations/009_convert_semver_string_to_object.ts

@@ -0,0 +1,16 @@
+import Release from '../models/Release.js'
+
+export async function up() {
+  const releases = await Release.find({})
+  for (const release of releases) {
+    const semver = release.get('semver')
+    if (semver !== undefined && typeof semver === typeof '') {
+      release.set('semver', semver)
+      await release.save()
+    }
+  }
+}
+
+export async function down() {
+  /* NOOP */
+}

backend/src/models/Release.ts

@@ -1,6 +1,8 @@
 import { Document, model, Schema } from 'mongoose'
 import MongooseDelete from 'mongoose-delete'
 
+import { semverObjectToString, semverStringToObject } from '../services/release.js'
+
 // This interface stores information about the properties on the base object.
 // It should be used for plain object representations, e.g. for sending to the
 // client.
@@ -35,12 +37,31 @@ export interface ImageRef {
 // object from Mongoose it should use this interface
 export type ReleaseDoc = ReleaseInterface & Document<any, any, ReleaseInterface>
 
-const ReleaseSchema = new Schema<ReleaseInterface>(
+export interface SemverObject {
+  major: number
+  minor: number
+  patch: number
+  metadata?: string
+}
+
+const ReleaseSchema = new Schema<ReleaseInterface & { semver: string | SemverObject }>(
   {
     modelId: { type: String, required: true },
     modelCardVersion: { type: Number, required: true },
 
-    semver: { type: String, required: true },
+    semver: {
+      type: Schema.Types.Mixed,
+      required: true,
+      set: function (semver: string) {
+        return semverStringToObject(semver)
+      },
+      get: function (semver: SemverObject | string) {
+        if (typeof semver === 'string') {
+          return semver
+        } else return semverObjectToString(semver)
+      },
+    },
+
     notes: { type: String, required: true },
 
     minor: { type: Boolean, required: true },
@@ -60,6 +81,8 @@ const ReleaseSchema = new Schema<ReleaseInterface>(
   {
     timestamps: true,
     collection: 'v2_releases',
+    toJSON: { getters: true },
+    toObject: { getters: true },
   },
 )
 

backend/src/routes/v2/release/getReleases.ts

@@ -17,6 +17,9 @@ export const getReleasesSchema = z.object({
       required_error: 'Must specify model id as URL parameter',
     }),
   }),
+  query: z.object({
+    q: z.string().optional(),
+  }),
 })
 
 registerPath({
@@ -49,9 +52,10 @@ export const getReleases = [
     req.audit = AuditInfo.ViewReleases
     const {
       params: { modelId },
+      query: { q },
     } = parse(req, getReleasesSchema)
 
-    const releases = await getModelReleases(req.user, modelId)
+    const releases = await getModelReleases(req.user, modelId, q)
     await audit.onViewReleases(req, releases)
 
     return res.json({

backend/src/services/release.ts

@@ -1,11 +1,12 @@
+import { Document, Schema } from 'mongoose'
 import semver from 'semver'
 import { Optional } from 'utility-types'
 
 import { ReleaseAction } from '../connectors/authorisation/actions.js'
 import authorisation from '../connectors/authorisation/index.js'
 import { FileInterface } from '../models/File.js'
 import { ModelDoc, ModelInterface } from '../models/Model.js'
-import Release, { ImageRef, ReleaseDoc, ReleaseInterface } from '../models/Release.js'
+import Release, { ImageRef, ReleaseDoc, ReleaseInterface, SemverObject } from '../models/Release.js'
 import ResponseModel, { ResponseKind } from '../models/Response.js'
 import { UserInterface } from '../models/User.js'
 import { WebhookEvent } from '../models/Webhook.js'
@@ -55,7 +56,8 @@
     const fileNames: Array<string> = []
 
     for (const fileId of release.fileIds) {
-      let file
+      let file: Document<unknown, any, FileInterface> &
+        Omit<FileInterface & Required<{ _id: Schema.Types.ObjectId }>, never>
       try {
         file = await getFileById(user, fileId)
       } catch (e) {
@@ -237,9 +239,11 @@
 export async function getModelReleases(
   user: UserInterface,
   modelId: string,
+  q?: string,
 ): Promise<Array<ReleaseDoc & { model: ModelInterface; files: FileInterface[] }>> {
+  const query = q === undefined ? { modelId } : getQuerySyntax(q, modelId)
   const results = await Release.aggregate()
-    .match({ modelId })
+    .match(query!)
     .sort({ updatedAt: -1 })
     .lookup({ from: 'v2_models', localField: 'modelId', foreignField: 'id', as: 'model' })
     .append({ $set: { model: { $arrayElemAt: ['$model', 0] } } })
@@ -248,7 +252,9 @@
   const model = await getModelById(user, modelId)
 
   const auths = await authorisation.releases(user, model, results, ReleaseAction.View)
-  return results.filter((_, i) => auths[i].success)
+  return results
+    .filter((_, i) => auths[i].success)
+    .map((result) => ({ ...result, semver: semverObjectToString(result.semver) }))
 }
 
 export async function getReleasesForExport(user: UserInterface, modelId: string, semvers: string[]) {
@@ -276,11 +282,36 @@
   return releases
 }
 
+export function semverStringToObject(semver: string) {
+  const vIdentifierIndex = semver.indexOf('v')
+  const trimmedSemver = vIdentifierIndex === -1 ? semver : semver.slice(vIdentifierIndex + 1)
+  const [version, metadata] = trimmedSemver.split('-')
+  const [major, minor, patch] = version.split('.')
+  const majorNum: number = Number(major)
+  const minorNum: number = Number(minor)
+  const patchNum: number = Number(patch)
+  return { major: majorNum, minor: minorNum, patch: patchNum, ...(metadata && { metadata }) }
+}
+
+export function semverObjectToString(semver: SemverObject) {
+  if (!semver) {
+    return ''
+  }
+  let metadata: string
+  if (semver.metadata != undefined) {
+    metadata = `-${semver.metadata}`
+  } else {
+    metadata = ``
+  }
+  return `${semver.major}.${semver.minor}.${semver.patch}${metadata}`
+}
+
 export async function getReleaseBySemver(user: UserInterface, modelId: string, semver: string) {
   const model = await getModelById(user, modelId)
+  const semverObj = semverStringToObject(semver)
   const release = await Release.findOne({
     modelId,
-    semver,
+    semver: semverObj,
   })
 
   if (!release) {
@@ -295,6 +326,168 @@
   return release
 }
 
+function getSemverQueryBounds(querySemver: string) {
+  const semverRangeStandardised = semver.validRange(querySemver, { includePrerelease: false })
+
+  if (!semverRangeStandardised) {
+    throw BadReq(`Semver range, '${querySemver}' is invalid `)
+  }
+
+  const [expressionA, expressionB] = semverRangeStandardised.split(' ')
+
+  let lowerSemver: string = '',
+    upperSemver: string = '',
+    lowerInclusivity = false,
+    upperInclusivity = false
+  if (expressionA.includes('>')) {
+    if (expressionA.includes('=')) {
+      lowerSemver = expressionA.replace('>=', '')
+      lowerInclusivity = true
+    } else {
+      lowerSemver = expressionA.replace('>', '')
+    }
+    //do check for expressionB
+    if (expressionB) {
+      if (expressionB.includes('=')) {
+        upperSemver = expressionB.replace('<=', '')
+        upperInclusivity = true
+      } else {
+        upperSemver = expressionB.replace('<', '')
+      }
+    }
+  } else {
+    if (expressionA.includes('=')) {
+      upperSemver = expressionA.replace('<=', '')
+      upperInclusivity = true
+    } else {
+      upperSemver = expressionA.replace('<', '')
+    }
+  }
+
+  let lowerSemverObj: { metadata?: string | undefined; major: number; minor: number; patch: number } = {
+      major: NaN,
+      minor: NaN,
+      patch: NaN,
+    },
+    upperSemverObj: { metadata?: string | undefined; major: number; minor: number; patch: number } = {
+      major: NaN,
+      minor: NaN,
+      patch: NaN,
+    }
+  if (lowerSemver) {
+    lowerSemverObj = semverStringToObject(lowerSemver)
+  }
+
+  if (upperSemver) {
+    upperSemverObj = semverStringToObject(upperSemver)
+  }
+
+  return { lowerSemverObj, upperSemverObj, lowerInclusivity, upperInclusivity }
+}
+
+function getQuerySyntax(querySemver: string | undefined, modelID: string) {
+  if (querySemver === undefined) {
+    return {
+      modelId: modelID,
+    }
+  }
+
+  const { lowerSemverObj, upperSemverObj, lowerInclusivity, upperInclusivity } = getSemverQueryBounds(querySemver)
+  interface QueryBoundInterface {
+    $or: (
+      | {
+          'semver.major':
+            | {
+                $lte: number
+              }
+            | {
+                $gte: number
+              }
+          'semver.minor':
+            | {
+                $lte: number
+              }
+            | { $gte: number }
+          'semver.patch':
+            | {
+                $gte: number
+              }
+            | { $gt: number }
+            | { $lte: number }
+            | { $lt: number }
+        }
+      | {
+          'semver.major':
+            | {
+                $gt: number
+              }
+            | { $lt: number }
+        }
+      | {
+          'semver.major':
+            | {
+                $gte: number
+              }
+            | { $lte: number }
+          'semver.minor':
+            | {
+                $gt: number
+              }
+            | { $lt: number }
+        }
+    )[]
+  }
+
+  const queryQueue: QueryBoundInterface[] = []
+
+  if (lowerSemverObj) {
+    const lowerQuery: QueryBoundInterface = {
+      $or: [
+        {
+          'semver.major': { $gte: lowerSemverObj.major },
+          'semver.minor': { $gte: lowerSemverObj.minor },
+          'semver.patch': lowerInclusivity ? { $gte: lowerSemverObj.patch } : { $gt: lowerSemverObj.patch },
+        },
+        {
+          'semver.major': { $gt: lowerSemverObj.major },
+        },
+        {
+          'semver.major': { $gte: lowerSemverObj.major },
+          'semver.minor': { $gt: lowerSemverObj.minor },
+        },
+      ],
+    }
+    queryQueue.push(lowerQuery)
+  }
+
+  if (upperSemverObj) {
+    const upperQuery: QueryBoundInterface = {
+      $or: [
+        {
+          'semver.major': { $lte: upperSemverObj.major },
+          'semver.minor': { $lte: upperSemverObj.minor },
+          'semver.patch': upperInclusivity ? { $lte: upperSemverObj.patch } : { $lt: upperSemverObj.patch },
+        },
+        {
+          'semver.major': { $lt: upperSemverObj.major },
+        },
+        {
+          'semver.major': { $lte: upperSemverObj.major },
+          'semver.minor': { $lt: upperSemverObj.minor },
+        },
+      ],
+    }
+    queryQueue.push(upperQuery)
+  }
+
+  const combinedQuery = {
+    modelId: modelID,
+    $and: queryQueue,
+  }
+
+  return combinedQuery
+}
+
 export async function deleteRelease(user: UserInterface, modelId: string, semver: string) {
   const model = await getModelById(user, modelId)
   if (model.settings.mirror.sourceModelId) {