@things-factory/mlops 9.1.19

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@things-factory/mlops",
+  "version": "9.1.19",
+  "main": "dist-server/index.js",
+  "browser": "dist-client/index.js",
+  "things-factory": true,
+  "license": "MIT",
+  "author": "Things-Factory Team",
+  "description": "MLOps module - ML lifecycle orchestration platform for Things-Factory",
+  "publishConfig": {
+    "access": "public",
+    "@things-factory:registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hatiolab/things-factory.git",
+    "directory": "packages/mlops"
+  },
+  "scripts": {
+    "build": "npm run build:server && npm run build:client",
+    "copy:files:client": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
+    "copy:files:server": "copyfiles -e \"./server/**/*.{ts,js}\" -u 1 \"./server/**/*\" dist-server",
+    "build:client": "npm run copy:files:client && npx tsc --p ./client/tsconfig.json",
+    "build:server": "npm run copy:files:server && npx tsc --p ./server/tsconfig.json",
+    "clean:client": "npx rimraf dist-client",
+    "clean:server": "npx rimraf dist-server",
+    "clean": "npm run clean:server && npm run clean:client",
+    "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
+  },
+  "dependencies": {
+    "@operato/app": "^9.0.0",
+    "@operato/data-grist": "^9.0.0",
+    "@operato/graphql": "^9.0.0",
+    "@operato/i18n": "^9.0.0",
+    "@operato/layout": "^9.0.0",
+    "@operato/shell": "^9.0.0",
+    "@things-factory/auth-base": "^9.1.19",
+    "@things-factory/integration-label-studio": "^9.1.19",
+    "@things-factory/integration-mlflow": "^9.1.19",
+    "@things-factory/shell": "^9.1.19"
+  },
+  "keywords": [
+    "things-factory",
+    "mlops",
+    "machine-learning",
+    "ml-platform",
+    "model-management",
+    "mlflow",
+    "label-studio"
+  ],
+  "gitHead": "078438034dbe19915108e89ff24024f7044a85a9"
+}

package/server/index.ts

@@ -0,0 +1,3 @@
+export * from './service/index.js'
+
+import './routes.js'

package/server/routes.ts

@@ -0,0 +1,13 @@
+/**
+ * MLOps Module Routes
+ *
+ * Register additional routes if needed (beyond GraphQL)
+ */
+
+// Example: Health check endpoint, webhooks, etc.
+// import Koa from 'koa'
+// import Router from 'koa-router'
+
+// process.on('bootstrap-module-domain-private-route', (app: Koa, router: Router) => {
+//   // Add custom routes here
+// })

package/server/service/index.ts

@@ -0,0 +1,29 @@
+/* EXPORT ENTITY TYPES */
+export * from './ml-model/ml-model'
+export * from './ml-pipeline/ml-pipeline'
+export * from './ml-pipeline-run/ml-pipeline-run'
+export * from './ml-deployment/ml-deployment'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as MLModelEntities, resolvers as MLModelResolvers } from './ml-model'
+import { entities as MLPipelineEntities, resolvers as MLPipelineResolvers } from './ml-pipeline'
+import { entities as MLPipelineRunEntities, resolvers as MLPipelineRunResolvers } from './ml-pipeline-run'
+import { entities as MLDeploymentEntities, resolvers as MLDeploymentResolvers } from './ml-deployment'
+
+export const entities = [
+  /* ENTITIES */
+  ...MLModelEntities,
+  ...MLPipelineEntities,
+  ...MLPipelineRunEntities,
+  ...MLDeploymentEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...MLModelResolvers,
+    ...MLPipelineResolvers,
+    ...MLPipelineRunResolvers,
+    ...MLDeploymentResolvers
+  ]
+}

package/server/service/ml-deployment/index.ts

@@ -0,0 +1,6 @@
+import { MLDeployment } from './ml-deployment.js'
+
+export const entities = [MLDeployment]
+export const resolvers = []
+
+// export * from './ml-deployment'

package/server/service/ml-deployment/ml-deployment.ts

@@ -0,0 +1,136 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { MLModel } from '../ml-model/ml-model'
+
+/**
+ * Deployment Status
+ */
+export enum DeploymentStatus {
+  DEPLOYING = 'DEPLOYING',
+  ACTIVE = 'ACTIVE',
+  FAILED = 'FAILED',
+  STOPPED = 'STOPPED'
+}
+
+registerEnumType(DeploymentStatus, {
+  name: 'DeploymentStatus',
+  description: 'Model deployment status'
+})
+
+/**
+ * Deployment Environment
+ */
+export enum DeploymentEnvironment {
+  DEVELOPMENT = 'DEVELOPMENT',
+  STAGING = 'STAGING',
+  PRODUCTION = 'PRODUCTION'
+}
+
+registerEnumType(DeploymentEnvironment, {
+  name: 'DeploymentEnvironment',
+  description: 'Deployment environment'
+})
+
+/**
+ * ML Deployment Entity
+ *
+ * Tracks model deployments to various environments
+ */
+@Entity('ml_deployments')
+@Index('ix_ml_deployment_0', ['domain', 'model'])
+@Index('ix_ml_deployment_1', ['environment', 'status'])
+@ObjectType({ description: 'ML Model deployment configuration' })
+export class MLDeployment {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Deployment ID' })
+  id: string
+
+  @ManyToOne(() => MLModel)
+  @Field(type => MLModel, { description: 'Deployed model' })
+  model: MLModel
+
+  @RelationId((deployment: MLDeployment) => deployment.model)
+  modelId: string
+
+  @Column({ nullable: true, comment: 'Deployment name' })
+  @Field({ description: 'Deployment name' })
+  name: string
+
+  @Column({ type: 'varchar', default: DeploymentEnvironment.DEVELOPMENT, comment: 'Environment' })
+  @Field(type => DeploymentEnvironment, { description: 'Deployment environment' })
+  environment: DeploymentEnvironment
+
+  @Column({ type: 'varchar', default: DeploymentStatus.DEPLOYING, comment: 'Status' })
+  @Field(type => DeploymentStatus, { description: 'Current deployment status' })
+  status: DeploymentStatus
+
+  @Column({ nullable: true, comment: 'Endpoint URL' })
+  @Field({ nullable: true, description: 'API endpoint URL' })
+  endpoint?: string
+
+  @Column({ type: 'simple-json', nullable: true, comment: 'Scaling configuration' })
+  @Field(type => String, { nullable: true, description: 'Scaling config as JSON' })
+  scalingConfig?: string
+
+  @Column({ type: 'simple-json', nullable: true, comment: 'Resource allocation' })
+  @Field(type => String, { nullable: true, description: 'Resource config as JSON' })
+  resources?: string
+
+  @Column({ type: 'timestamp', nullable: true, comment: 'Deployment time' })
+  @Field({ nullable: true, description: 'Deployed at' })
+  deployedAt?: Date
+
+  @Column({ type: 'int', default: 0, comment: 'Total prediction count' })
+  @Field(type => Int, { description: 'Total predictions served' })
+  predictionCount: number
+
+  @Column({ type: 'float', nullable: true, comment: 'Average latency (ms)' })
+  @Field({ nullable: true, description: 'Average latency in ms' })
+  avgLatency?: number
+
+  @Column({ type: 'float', nullable: true, comment: 'Error rate' })
+  @Field({ nullable: true, description: 'Error rate (0-1)' })
+  errorRate?: number
+
+  @Column({ type: 'simple-json', nullable: true, comment: 'Deployment metadata' })
+  @Field(type => String, { nullable: true, description: 'Metadata as JSON' })
+  metadata?: string
+
+  @ManyToOne(() => Domain)
+  @Field({ nullable: true, description: 'Domain' })
+  domain?: Domain
+
+  @RelationId((deployment: MLDeployment) => deployment.domain)
+  domainId?: string
+
+  @ManyToOne(() => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'Deployed by' })
+  deployedBy?: User
+
+  @RelationId((deployment: MLDeployment) => deployment.deployedBy)
+  deployedById?: string
+
+  @CreateDateColumn()
+  @Field({ description: 'Created at' })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ description: 'Updated at' })
+  updatedAt: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true, description: 'Deleted at' })
+  deletedAt?: Date
+}

package/server/service/ml-model/index.ts

@@ -0,0 +1,9 @@
+import { MLModel } from './ml-model'
+import { MLModelQuery } from './ml-model-query'
+import { MLModelMutation } from './ml-model-mutation'
+
+export const entities = [MLModel]
+export const resolvers = [MLModelQuery, MLModelMutation]
+
+// export * from './ml-model'
+// export * from './ml-model-types'

package/server/service/ml-model/ml-model-mutation.ts

@@ -0,0 +1,171 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { MLModel, ModelStage } from './ml-model'
+import { RegisterMLModelInput, UpdateMLModelInput, PromoteModelInput } from './ml-model-types'
+
+@Resolver(MLModel)
+export class MLModelMutation {
+  /**
+   * Register new ML model
+   */
+  @Mutation(returns => MLModel, {
+    description: 'Register new ML model in the system'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "mutation")')
+  async registerMLModel(@Arg('input') input: RegisterMLModelInput, @Ctx() context: ResolverContext): Promise<MLModel> {
+    const { domain, user } = context.state
+
+    // Check if model with same name and version exists
+    const existing = await getRepository(MLModel).findOne({
+      where: {
+        domain: { id: domain.id },
+        name: input.name,
+        version: input.version
+      }
+    })
+
+    if (existing) {
+      throw new Error(`Model ${input.name} version ${input.version} already exists`)
+    }
+
+    const model = getRepository(MLModel).create({
+      ...input,
+      stage: input.stage || ModelStage.NONE,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return await getRepository(MLModel).save(model)
+  }
+
+  /**
+   * Update ML model
+   */
+  @Mutation(returns => MLModel, {
+    description: 'Update ML model information'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "mutation")')
+  async updateMLModel(
+    @Arg('id') id: string,
+    @Arg('input') input: UpdateMLModelInput,
+    @Ctx() context: ResolverContext
+  ): Promise<MLModel> {
+    const { domain, user } = context.state
+
+    const model = await getRepository(MLModel).findOne({
+      where: { id, domain: { id: domain.id } }
+    })
+
+    if (!model) {
+      throw new Error(`Model ${id} not found`)
+    }
+
+    Object.assign(model, input, { updater: user })
+
+    return await getRepository(MLModel).save(model)
+  }
+
+  /**
+   * Promote model to target stage
+   */
+  @Mutation(returns => MLModel, {
+    description: 'Promote model to target deployment stage (Staging/Production)'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "mutation")')
+  async promoteMLModel(@Arg('input') input: PromoteModelInput, @Ctx() context: ResolverContext): Promise<MLModel> {
+    const { domain, user } = context.state
+
+    const model = await getRepository(MLModel).findOne({
+      where: { id: input.modelId, domain: { id: domain.id } }
+    })
+
+    if (!model) {
+      throw new Error(`Model ${input.modelId} not found`)
+    }
+
+    // Validate stage transition
+    if (model.stage === ModelStage.ARCHIVED) {
+      throw new Error('Cannot promote archived model')
+    }
+
+    if (input.targetStage === ModelStage.NONE) {
+      throw new Error('Cannot promote to None stage')
+    }
+
+    // If promoting to Production, demote other Production models with same name
+    if (input.targetStage === ModelStage.PRODUCTION) {
+      await getRepository(MLModel).update(
+        {
+          domain: { id: domain.id },
+          name: model.name,
+          stage: ModelStage.PRODUCTION
+        },
+        {
+          stage: ModelStage.STAGING
+        }
+      )
+    }
+
+    model.stage = input.targetStage
+    model.updater = user
+
+    return await getRepository(MLModel).save(model)
+  }
+
+  /**
+   * Archive ML model
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Archive ML model (soft delete)'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "mutation")')
+  async archiveMLModel(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain } = context.state
+
+    const model = await getRepository(MLModel).findOne({
+      where: { id, domain: { id: domain.id } }
+    })
+
+    if (!model) {
+      throw new Error(`Model ${id} not found`)
+    }
+
+    if (model.stage === ModelStage.PRODUCTION) {
+      throw new Error('Cannot archive production model. Demote it first.')
+    }
+
+    model.stage = ModelStage.ARCHIVED
+
+    await getRepository(MLModel).save(model)
+
+    return true
+  }
+
+  /**
+   * Delete ML model
+   */
+  @Mutation(returns => Boolean, {
+    description: 'Delete ML model permanently'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "mutation")')
+  async deleteMLModel(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain } = context.state
+
+    const model = await getRepository(MLModel).findOne({
+      where: { id, domain: { id: domain.id } }
+    })
+
+    if (!model) {
+      throw new Error(`Model ${id} not found`)
+    }
+
+    if (model.stage === ModelStage.PRODUCTION) {
+      throw new Error('Cannot delete production model')
+    }
+
+    await getRepository(MLModel).softDelete({ id })
+
+    return true
+  }
+}

package/server/service/ml-model/ml-model-query.ts

@@ -0,0 +1,97 @@
+import { Resolver, Query, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { MLModel, ModelStage } from './ml-model'
+
+@Resolver(MLModel)
+export class MLModelQuery {
+  /**
+   * Get all ML models
+   */
+  @Query(returns => [MLModel], {
+    description: 'Get all ML models in the system'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "query")')
+  async mlModels(@Ctx() context: ResolverContext): Promise<MLModel[]> {
+    const { domain } = context.state
+
+    return await getRepository(MLModel).find({
+      where: { domain: { id: domain.id } },
+      order: { createdAt: 'DESC' },
+      relations: ['creator', 'updater']
+    })
+  }
+
+  /**
+   * Get ML model by ID
+   */
+  @Query(returns => MLModel, {
+    description: 'Get ML model by ID',
+    nullable: true
+  })
+  @Directive('@privilege(category: "mlops", privilege: "query")')
+  async mlModel(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<MLModel | undefined> {
+    const { domain } = context.state
+
+    return await getRepository(MLModel).findOne({
+      where: { id, domain: { id: domain.id } },
+      relations: ['creator', 'updater']
+    })
+  }
+
+  /**
+   * Get models by stage
+   */
+  @Query(returns => [MLModel], {
+    description: 'Get models by deployment stage'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "query")')
+  async mlModelsByStage(
+    @Arg('stage', type => ModelStage) stage: ModelStage,
+    @Ctx() context: ResolverContext
+  ): Promise<MLModel[]> {
+    const { domain } = context.state
+
+    return await getRepository(MLModel).find({
+      where: { domain: { id: domain.id }, stage },
+      order: { updatedAt: 'DESC' },
+      relations: ['creator', 'updater']
+    })
+  }
+
+  /**
+   * Get models by name (all versions)
+   */
+  @Query(returns => [MLModel], {
+    description: 'Get all versions of a model by name'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "query")')
+  async mlModelVersions(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<MLModel[]> {
+    const { domain } = context.state
+
+    return await getRepository(MLModel).find({
+      where: { domain: { id: domain.id }, name },
+      order: { createdAt: 'DESC' },
+      relations: ['creator', 'updater']
+    })
+  }
+
+  /**
+   * Get models by Label Studio project
+   */
+  @Query(returns => [MLModel], {
+    description: 'Get models associated with Label Studio project'
+  })
+  @Directive('@privilege(category: "mlops", privilege: "query")')
+  async mlModelsByLabelStudioProject(
+    @Arg('projectId', type => Number) projectId: number,
+    @Ctx() context: ResolverContext
+  ): Promise<MLModel[]> {
+    const { domain } = context.state
+
+    return await getRepository(MLModel).find({
+      where: { domain: { id: domain.id }, labelStudioProjectId: projectId },
+      order: { createdAt: 'DESC' },
+      relations: ['creator', 'updater']
+    })
+  }
+}

package/server/service/ml-model/ml-model-types.ts

@@ -0,0 +1,71 @@
+import { InputType, Field, Int } from 'type-graphql'
+import { ModelStage, ModelFramework } from './ml-model'
+
+@InputType({ description: 'Input for registering ML model' })
+export class RegisterMLModelInput {
+  @Field({ description: 'Model name' })
+  name: string
+
+  @Field({ description: 'Model version' })
+  version: string
+
+  @Field({ nullable: true, description: 'Model description' })
+  description?: string
+
+  @Field(type => ModelStage, { nullable: true, description: 'Initial stage' })
+  stage?: ModelStage
+
+  @Field(type => ModelFramework, { nullable: true, description: 'ML framework' })
+  framework?: ModelFramework
+
+  @Field({ nullable: true, description: 'Model metrics as JSON string' })
+  metrics?: string
+
+  @Field({ nullable: true, description: 'Model metadata as JSON string' })
+  metadata?: string
+
+  @Field({ nullable: true, description: 'Artifact URI' })
+  artifactUri?: string
+
+  @Field({ nullable: true, description: 'MLflow run ID' })
+  mlflowRunId?: string
+
+  @Field({ nullable: true, description: 'MLflow experiment ID' })
+  mlflowExperimentId?: string
+
+  @Field(type => Int, { nullable: true, description: 'Label Studio project ID' })
+  labelStudioProjectId?: number
+
+  @Field({ nullable: true, description: 'Tags as JSON array string' })
+  tags?: string
+}
+
+@InputType({ description: 'Input for updating ML model' })
+export class UpdateMLModelInput {
+  @Field({ nullable: true, description: 'Model description' })
+  description?: string
+
+  @Field(type => ModelStage, { nullable: true, description: 'Stage' })
+  stage?: ModelStage
+
+  @Field({ nullable: true, description: 'Model metrics as JSON string' })
+  metrics?: string
+
+  @Field({ nullable: true, description: 'Model metadata as JSON string' })
+  metadata?: string
+
+  @Field({ nullable: true, description: 'Tags as JSON array string' })
+  tags?: string
+}
+
+@InputType({ description: 'Input for promoting model stage' })
+export class PromoteModelInput {
+  @Field({ description: 'Model ID to promote' })
+  modelId: string
+
+  @Field(type => ModelStage, { description: 'Target stage' })
+  targetStage: ModelStage
+
+  @Field({ nullable: true, description: 'Promotion notes' })
+  notes?: string
+}