@things-factory/figure-service 10.1.68 → 10.1.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/figure-service",
-  "version": "10.1.68",
+  "version": "10.1.70",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,7 +23,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@hatiolab/figure-model": "^0.1.80",
+    "@hatiolab/figure-model": "^0.1.82",
     "@operato/typeorm-history": "^10.0.0",
     "@things-factory/ai-client-base": "^10.1.53",
     "@things-factory/auth-base": "^10.1.47",
@@ -33,5 +33,5 @@
     "graphql-upload": "^15.0.2",
     "koa-router": "^7.4.0"
   },
-  "gitHead": "0afdbab94f3cc477d0db1807d810e9d01aeb67a1"
+  "gitHead": "7c9c614b0cb1d02d401211db76ec0ca0ead344af"
 }

package/server/index.ts

@@ -10,6 +10,20 @@ import './routes.js'
 import { registerFigureToolCategories } from './service/figure/figure-tools.js'
 registerFigureToolCategories()
 
+/*
+ * The built-in recipes into the system domain, as auth-base fills its privileges: once, and again gives the same result
+ * (ADR-0095 condition 2). A recipe that fails its check is said here, not half put in.
+ */
+import { seedBuiltInRecipes } from './service/figure-recipe/figure-recipe-store.js'
+process.on('bootstrap-module-start' as any, async () => {
+  try {
+    const { added, skipped, refused } = await seedBuiltInRecipes()
+    console.log(`[figure-service:bootstrap] recipes added ${added.length}, already there ${skipped.length}${refused.length ? `, refused: ${refused.join(' | ')}` : ''}`)
+  } catch (error) {
+    console.error('[figure-service:bootstrap] recipes were not seeded:', error)
+  }
+})
+
 export * from './service/index.js'
 export * from './migrations/index.js'
 export { registerFigureToolCategories } from './service/figure/figure-tools.js'

package/server/service/figure-recipe/figure-recipe-db.test.ts

@@ -0,0 +1,123 @@
+/**
+ * 조각 — 시드 · 도메인 규칙 · 저장 검사를 **sqlite 를 실제로 들고** 확인한다(ADR-0095 조건 2 · 3).
+ *
+ * 규칙이 질의에 있으므로 DB 없이 시험하면 초록이어도 뜻이 없다. figure-rename-db 와 같이 tsc 산출물을 든다.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+
+let dataSource: DataSource | null = null
+let FigureRecipe: any
+let store: any
+
+function loadCompiled(modulePath: string): any {
+  const { existsSync } = require('fs')
+  const { join } = require('path')
+  const resolved = join(__dirname, '..', '..', '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved)) throw new Error(`figure-service 산출물이 없다: ${resolved} — 먼저 빌드할 것: yarn workspace @things-factory/figure-service build:server`)
+  return require(resolved)
+}
+
+beforeAll(async () => {
+  FigureRecipe = loadCompiled('service/figure-recipe/figure-recipe').FigureRecipe
+  store = loadCompiled('service/figure-recipe/figure-recipe-store')
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, FigureRecipe],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+  dataSource = null
+})
+
+let SYSTEM: any
+let CHILD: any
+
+beforeEach(async () => {
+  await dataSource!.synchronize(true)
+  const domains = dataSource!.getRepository(shell.Domain)
+  SYSTEM = await domains.save({ name: 'SYSTEM', subdomain: 'system', systemFlag: true })
+  CHILD = await domains.save({ name: 'plant', subdomain: 'plant', parentId: SYSTEM.id })
+})
+
+const rows = async () => (await dataSource!.getRepository(FigureRecipe).find({ relations: ['domain'], order: { name: 'ASC' } })).map((r: any) => [r.domain.subdomain, r.name])
+
+describe('조각 — 시드', () => {
+  it('★ figure-model 이 싣는 조각 셋이 system 에 들어가고, 다시 실어도 같다 — 있으면 건너뛰고 덮지 않는다', async () => {
+    const first = await store.seedBuiltInRecipes()
+    expect(first.added).toEqual(['hinged-door', 'roller-row', 'sliding-door'])
+    expect(first.refused).toEqual([])
+    const repo = dataSource!.getRepository(FigureRecipe)
+    const door = await repo.findOne({ where: { name: 'sliding-door' } })
+    await repo.save({ ...door, state: 'draft' })
+
+    const again = await store.seedBuiltInRecipes()
+    expect(again.added).toEqual([])
+    expect(again.skipped).toEqual(['hinged-door', 'roller-row', 'sliding-door'])
+    expect(await rows()).toEqual([['system', 'hinged-door'], ['system', 'roller-row'], ['system', 'sliding-door']])
+    expect((await repo.findOne({ where: { name: 'sliding-door' } })).state).toBe('draft')
+  })
+})
+
+describe('조각 — 읽기는 도형과 같은 도메인 규칙', () => {
+  it('★ 자식 도메인은 부모의 조각을 보고, 같은 이름의 제 조각이 그것을 대신한다; 초안은 모두를 물을 때만', async () => {
+    await store.seedBuiltInRecipes()
+    const door = JSON.parse(store.builtInRecipes().find((r: any) => r.name === 'sliding-door').source)
+    door.title = { ko: '우리 공장 미닫이 문' }
+    await store.saveRecipe(CHILD, JSON.stringify(door))
+    const seen = await store.recipesFor({ id: CHILD.id, parentId: SYSTEM.id }, 'released')
+    expect(seen.map((r: any) => r.name)).toEqual(['hinged-door', 'roller-row', 'sliding-door'])
+    expect(JSON.parse(seen.find((r: any) => r.name === 'sliding-door').source).title.ko).toBe('우리 공장 미닫이 문')
+
+    const hinged = JSON.parse(store.builtInRecipes().find((r: any) => r.name === 'hinged-door').source)
+    await store.saveRecipe(CHILD, JSON.stringify({ ...hinged, name: 'shop-door' }), 'draft')
+    expect((await store.recipesFor({ id: CHILD.id, parentId: SYSTEM.id }, 'released')).map((r: any) => r.name)).not.toContain('shop-door')
+    expect((await store.recipesFor({ id: CHILD.id, parentId: SYSTEM.id })).map((r: any) => r.name)).toContain('shop-door')
+    expect((await store.recipesFor({ id: SYSTEM.id })).map((r: any) => r.name)).not.toContain('shop-door')
+  })
+})
+
+describe('조각 — 저장은 빈 방에 넣어 본 뒤에', () => {
+  it('★ 기본값으로 넣을 수 없는 조각은 커널의 말 그대로 거절되고 저장되지 않는다', async () => {
+    const door = JSON.parse(store.builtInRecipes().find((r: any) => r.name === 'sliding-door').source)
+    door.steps[2].source.part = 'nowhere'
+    await expect(store.saveRecipe(CHILD, JSON.stringify(door))).rejects.toThrow(/steps\[2\]/)
+    expect(await rows()).toEqual([])
+  })
+})
+
+describe('조각 — 제 도메인 것만 바꾼다', () => {
+  it('★ 자식은 부모의 조각을 발행 · 삭제하지 못한다; 제 것은 초안으로 돌리면 모델러 목록에서 빠지고, 지우면 부모 것이 다시 보인다', async () => {
+    await store.seedBuiltInRecipes()
+    const child = { id: CHILD.id, parentId: SYSTEM.id }
+    await expect(store.deleteRecipe(child, 'sliding-door')).rejects.toThrow(/copied here to be changed/)
+    await expect(store.setRecipeState(child, 'sliding-door', 'draft')).rejects.toThrow(/copied here/)
+
+    const door = JSON.parse(store.builtInRecipes().find((r: any) => r.name === 'sliding-door').source)
+    door.title = { ko: '우리 문' }
+    await store.saveRecipe(CHILD, JSON.stringify(door))
+    await store.setRecipeState(child, 'sliding-door', 'draft')
+    const released = await store.recipesFor(child, 'released')
+    expect(JSON.parse(released.find((r: any) => r.name === 'sliding-door').source).title.ko).not.toBe('우리 문')
+
+    await store.deleteRecipe(child, 'sliding-door')
+    const all = await store.recipesFor(child)
+    expect(all.find((r: any) => r.name === 'sliding-door').domainId).toBe(SYSTEM.id)
+  })
+})

package/server/service/figure-recipe/figure-recipe-resolver.ts

@@ -0,0 +1,42 @@
+import { Arg, Ctx, Directive, Mutation, Query, Resolver, UseMiddleware } from 'type-graphql'
+
+import { SpeakRefusals } from '@things-factory/shell'
+
+import { FigureRecipe } from './figure-recipe.js'
+import { deleteRecipe, recipesFor, saveRecipe, setRecipeState } from './figure-recipe-store.js'
+
+@Resolver(FigureRecipe)
+@UseMiddleware(SpeakRefusals)
+export class FigureRecipeResolver {
+  @Directive('@privilege(category: "figure", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => [FigureRecipe], { description: "The recipes this domain sees: its own and its parent's (its own stand in by name). Released ones unless all is asked." })
+  async figureRecipes(@Arg('all', { nullable: true, description: 'Drafts as well.' }) all: boolean, @Ctx() context: ResolverContext): Promise<FigureRecipe[]> {
+    return await recipesFor(context.state.domain, all ? undefined : 'released')
+  }
+
+  @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => FigureRecipe, { description: 'Saves a recipe into this domain by its name, after putting it into an empty room with its defaults (ADR-0095).' })
+  async saveFigureRecipe(
+    @Arg('source', { description: 'The recipe JSON (figure-model V3Recipe).' }) source: string,
+    @Arg('state', { nullable: true, description: "'draft' or 'released' (the default)." }) state: string,
+    @Ctx() context: ResolverContext
+  ): Promise<FigureRecipe> {
+    return await saveRecipe(context.state.domain, source, state === 'draft' ? 'draft' : 'released')
+  }
+
+  @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => FigureRecipe, { description: "Releases a recipe of this domain's own, or takes it back to draft. A parent's recipe is copied in to be changed." })
+  async setFigureRecipeState(
+    @Arg('name', { description: 'The recipe name.' }) name: string,
+    @Arg('state', { description: "'draft' or 'released'." }) state: string,
+    @Ctx() context: ResolverContext
+  ): Promise<FigureRecipe> {
+    return await setRecipeState(context.state.domain, name, state === 'draft' ? 'draft' : 'released')
+  }
+
+  @Directive('@privilege(category: "figure", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: "Deletes a recipe of this domain's own. Figures it was put into keep their parts." })
+  async deleteFigureRecipe(@Arg('name', { description: 'The recipe name.' }) name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    return await deleteRecipe(context.state.domain, name)
+  }
+}

package/server/service/figure-recipe/figure-recipe-store.ts

@@ -0,0 +1,101 @@
+import { readdirSync, readFileSync } from 'fs'
+import { dirname, join } from 'path'
+import { In } from 'typeorm'
+
+import { checkV3Recipe } from '@hatiolab/figure-model'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { FigureRecipe } from './figure-recipe.js'
+
+/**
+ * The recipes a domain sees (ADR-0095 condition 2): its own and its parent's, as figures are read. A recipe of the
+ * domain's own stands in for the parent's of the same name.
+ */
+export async function recipesFor(domain: { id: string; parentId?: string | null }, state?: 'released'): Promise<FigureRecipe[]> {
+  const ids = [domain.id, domain.parentId].filter(Boolean) as string[]
+  const rows = await getRepository(FigureRecipe).find({
+    where: { domain: { id: In(ids) }, ...(state ? { state } : {}) },
+    relations: ['domain'],
+    order: { name: 'ASC' }
+  })
+  const byName = new Map<string, FigureRecipe>()
+  for (const row of rows) {
+    const mine = row.domainId === domain.id || (row.domain as Domain | undefined)?.id === domain.id
+    if (mine || !byName.has(row.name!)) byName.set(row.name!, row)
+  }
+  return [...byName.values()]
+}
+
+/**
+ * A recipe saved into a domain, by its name: checked first by putting it into the test room with its defaults
+ * (figure-model `checkV3Recipe`). Refused, it is not saved and the kernel's sentence goes back as it is.
+ */
+export async function saveRecipe(domain: Domain, source: unknown, state: 'draft' | 'released' = 'released'): Promise<FigureRecipe> {
+  const recipe = checkV3Recipe(typeof source === 'string' ? JSON.parse(source) : source)
+  const repository = getRepository(FigureRecipe)
+  const existing = await repository.findOne({ where: { domain: { id: domain.id }, name: recipe.name } })
+  return await repository.save({ ...(existing ?? {}), domain, name: recipe.name, source: JSON.stringify(recipe), state })
+}
+
+/**
+ * A recipe of the domain's own, by name. A parent's recipe is not the domain's to change: it is copied in under the same
+ * name (`saveRecipe`), and the copy stands in for it.
+ */
+async function ownRecipe(domain: { id: string }, name: string): Promise<FigureRecipe> {
+  const row = await getRepository(FigureRecipe).findOne({ where: { domain: { id: domain.id }, name } })
+  if (!row) throw new Error(`${name} is not a recipe of this domain; a parent's recipe is copied here to be changed`)
+  return row
+}
+
+/** Released or back to draft: only released recipes are offered in the modeller. */
+export async function setRecipeState(domain: { id: string }, name: string, state: 'draft' | 'released'): Promise<FigureRecipe> {
+  const row = await ownRecipe(domain, name)
+  return await getRepository(FigureRecipe).save({ ...row, state })
+}
+
+/**
+ * A recipe of the domain's own taken away. Figures it was put into keep their parts -- nothing ties them to it
+ * (ADR-0095). Where the parent has one by that name, the parent's is seen again.
+ */
+export async function deleteRecipe(domain: { id: string }, name: string): Promise<boolean> {
+  const row = await ownRecipe(domain, name)
+  await getRepository(FigureRecipe).softRemove(row)
+  return true
+}
+
+/** The recipes figure-model ships (`recipes/*.json`), as they are. */
+export function builtInRecipes(): Array<{ name: string; source: string }> {
+  const dir = join(dirname(require.resolve('@hatiolab/figure-model/package.json')), 'recipes')
+  return readdirSync(dir)
+    .filter(file => file.endsWith('.json'))
+    .sort()
+    .map(file => {
+      const source = readFileSync(join(dir, file), 'utf-8')
+      return { name: JSON.parse(source).name, source }
+    })
+}
+
+/**
+ * The built-in recipes put into the system domain (ADR-0095 condition 2): once, and again gives the same result -- a
+ * recipe already there by name is skipped, not overwritten, so a system recipe someone changed stays as they left it.
+ * Each is checked as a saved one is; one that fails is left out and said, not half put in.
+ */
+export async function seedBuiltInRecipes(): Promise<{ added: string[]; skipped: string[]; refused: string[] }> {
+  const system = await getRepository(Domain).findOne({ where: { systemFlag: true } })
+  const result = { added: [] as string[], skipped: [] as string[], refused: [] as string[] }
+  if (!system) return result
+  const repository = getRepository(FigureRecipe)
+  for (const { name, source } of builtInRecipes()) {
+    if (await repository.count({ where: { domain: { id: system.id }, name } })) {
+      result.skipped.push(name)
+      continue
+    }
+    try {
+      await saveRecipe(system, source)
+      result.added.push(name)
+    } catch (error) {
+      result.refused.push(`${name}: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+  return result
+}

package/server/service/figure-recipe/figure-recipe.ts

@@ -0,0 +1,51 @@
+import { Column, CreateDateColumn, DeleteDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+import { Field, ID, ObjectType } from 'type-graphql'
+
+import { Domain, longTextColumn } from '@things-factory/shell'
+
+/**
+ * FigureRecipe — 조각 하나(ADR-0095).
+ *
+ * 조각은 매개변수가 붙은 제안 명령 목록이다. 형식은 `@hatiolab/figure-model` 의 `V3Recipe` 가 정하고, 여기에는
+ * 그 원본을 통째로 담는다 — Figure 가 자산을 `source` 로 담는 것과 같다. 매개변수 · 명령을 컬럼으로 두지 않는다.
+ * 넣은 뒤의 부품은 조각과 이어지지 않으므로, 이 행을 고치거나 지워도 도형은 바뀌지 않는다.
+ */
+@Entity()
+@Index('ix_figure_recipe_1', (recipe: FigureRecipe) => [recipe.domain, recipe.name], { unique: true, where: '"deleted_at" IS NULL' })
+@ObjectType({ description: 'A recipe: a list of figure authoring commands with parameters (ADR-0095).' })
+export class FigureRecipe {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { nullable: true, description: 'Unique identifier for the recipe.' })
+  readonly id?: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true, description: 'The domain this recipe belongs to.' })
+  domain?: Domain
+
+  @RelationId((recipe: FigureRecipe) => recipe.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ description: 'The recipe name, unique per domain: lower case, digits and hyphens.' })
+  name?: string
+
+  @Column({ nullable: true, ...longTextColumn() })
+  @Field({ nullable: true, description: 'The recipe JSON (figure-model V3Recipe).' })
+  source?: string
+
+  @Column({ nullable: true, default: 'released' })
+  @Field({ nullable: true, description: "'draft' or 'released'. Only released recipes are offered in the modeller." })
+  state?: 'draft' | 'released'
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'When the recipe was created.' })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'When the recipe was last changed.' })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true, description: 'When the recipe was deleted.' })
+  deletedAt?: Date
+}

package/server/service/figure-recipe/index.ts

@@ -0,0 +1,5 @@
+import { FigureRecipe } from './figure-recipe.js'
+import { FigureRecipeResolver } from './figure-recipe-resolver.js'
+
+export const entities = [FigureRecipe]
+export const resolvers = [FigureRecipeResolver]

package/server/service/index.ts

@@ -3,6 +3,8 @@ export * from './figure/figure.js'
 export * from './figure/figure-type.js'
 export * from './figure/figure-format.js'
 export * from './figure/figure-history.js'
+export * from './figure-recipe/figure-recipe.js'
+export { recipesFor, saveRecipe, seedBuiltInRecipes, builtInRecipes } from './figure-recipe/figure-recipe-store.js'
 
 // Entities, resolvers
 import {
@@ -10,8 +12,9 @@ import {
   resolvers as FigureResolvers,
   subscribers as FigureSubscribers
 } from './figure/index.js'
+import { entities as RecipeEntities, resolvers as RecipeResolvers } from './figure-recipe/index.js'
 
-export const entities = [...FigureEntities]
+export const entities = [...FigureEntities, ...RecipeEntities]
 
 /* 판본 스냅샷을 뜨는 구독자. 셸이 이 이름으로 모아 TypeORM 에 등록한다(board-service 와 같다). */
 export const subscribers = [...FigureSubscribers]
@@ -27,5 +30,5 @@ export const subscribers = [...FigureSubscribers]
  * board-service, ops-master and font-base all export the shape below.
  */
 export const schema = {
-  resolverClasses: [...FigureResolvers]
+  resolverClasses: [...FigureResolvers, ...RecipeResolvers]
 }