@fugood/bricks-project 2.21.0-beta.16-1 → 2.21.0-beta.17-1

package/compile/index.ts

@@ -28,16 +28,23 @@ import type {
   Subspace,
 } from '../types'
 
-const compileProperty = (property, result = {}) => {
+const compileProperty = (property, errorReference: string, result = {}) => {
   if (Array.isArray(property)) {
-    return property.map((p) => compileProperty(p, result))
+    return property.map((p) => compileProperty(p, errorReference))
   }
-  if (property?.__typename === 'DataLink' && property.data?.())
-    return `PROPERTY_BANK#${property.data().id}`
-  if (typeof property === 'function') return property()?.id // defined type instance getter
-  if (typeof property === 'object') {
+  if (property?.__typename === 'DataLink') {
+    const data = property.data?.()
+    if (!data?.id) throw new Error(`Invalid DataLink reference ${errorReference}`)
+    return `PROPERTY_BANK#${data.id}`
+  }
+  if (typeof property === 'function') {
+    const instance = property()
+    if (!instance?.id) throw new Error(`Invalid ID reference ${errorReference}`)
+    return instance?.id // defined type instance getter
+  }
+  if (property && typeof property === 'object') {
     return Object.entries(property).reduce((acc, [key, value]) => {
-      acc[key] = compileProperty(value, {})
+      acc[key] = compileProperty(value, errorReference)
       return acc
     }, result)
   }
@@ -48,8 +55,13 @@ const convertOutletKey = (templateKey: string, key: string) => {
   return `${templateKey}_${_.snakeCase(key).toUpperCase()}`
 }
 
-const compileOutlets = (templateKey: string, outlets: { [key: string]: () => Data }) => {
+const compileOutlets = (
+  templateKey: string,
+  outlets: { [key: string]: () => Data },
+  errorReference: string,
+) => {
   return Object.entries(outlets).reduce((acc, [key, data]) => {
+    if (!data()?.id) throw new Error(`Invalid data reference ${errorReference}`)
     acc[convertOutletKey(templateKey, key)] = data().id
     return acc
   }, {})
@@ -61,8 +73,13 @@ const convertEventKey = (templateKey: string, key: string) => {
 
 const basicAnimationEvents = ['show', 'standby', 'breatheStart']
 
-const compileAnimations = (templateKey: string, animations: { [key: string]: Animation }) => {
+const compileAnimations = (
+  templateKey: string,
+  animations: { [key: string]: Animation },
+  errorReference: string,
+) => {
   return Object.entries(animations).reduce((acc, [key, animation]) => {
+    if (!animation?.id) throw new Error(`Invalid animation reference ${errorReference}`)
     acc[convertEventKey(basicAnimationEvents.includes(key) ? 'BRICK' : templateKey, key)] =
       `ANIMATION#${animation.id}`
     return acc
@@ -75,9 +92,9 @@ const compileActionParam = (templateKey: string, actionName: string, paramName:
 const compileEvents = (
   templateKey: string,
   eventMap: { [key: string]: Array<EventAction> },
-  options = { camelCase: false },
+  options = { camelCase: false, errorReference: '' },
 ) => {
-  const { camelCase } = options
+  const { camelCase, errorReference } = options
   return Object.entries(eventMap).reduce((acc, [key, events]) => {
     acc[convertEventKey(templateKey, key)] = events.map((event) => {
       const { handler, action } = event
@@ -93,7 +110,7 @@ const compileEvents = (
         handlerKey = instance?.id
         handlerTemplateKey = instance?.templateKey
       }
-      if (!handlerKey) throw new Error(`Invalid handler: ${handler}`)
+      if (!handlerKey) throw new Error(`Invalid handler: ${handler} ${errorReference}`)
 
       const parameterList: Array<object> = []
       if (Object.hasOwn(action, 'params')) {
@@ -104,7 +121,7 @@ const compileEvents = (
               ? compileActionParam(handlerTemplateKey, action.__actionName, input)
               : input,
             [camelCase ? 'resultFromSender' : 'result_from_sender']:
-              mapping || compileProperty(value),
+              mapping || compileProperty(value, errorReference),
           }
           if (mapping) param[camelCase ? 'resultDataMapping' : 'result_data_mapping'] = true
           parameterList.push(param)
@@ -116,7 +133,7 @@ const compileEvents = (
           const param = {
             [camelCase ? 'inputToReceiver' : 'input_to_receiver']: input().id,
             [camelCase ? 'resultFromSender' : 'result_from_sender']:
-              mapping || compileProperty(value),
+              mapping || compileProperty(value, errorReference),
           }
           if (mapping) param[camelCase ? 'resultDataMapping' : 'result_data_mapping'] = true
           parameterList.push(param)
@@ -133,17 +150,22 @@ const compileEvents = (
   }, {})
 }
 
-const compileSwitchConds = (templateKey, conds) =>
-  (conds || []).map((item: any) => {
+const compileSwitchConds = (templateKey, conds, errorReference) =>
+  (conds || []).map((item: any, index) => {
     const result: any = { method: item.method }
+    if (!item.cond) return result
     if (item.cond.__typename === 'SwitchCondData') {
       const cond = item.cond as SwitchCondData
       result.type = 'property_bank'
+      if (!cond.data().id)
+        throw new Error(`Invalid data reference in conds index: ${index} ${errorReference}`)
       result.key = cond.data().id
       result.value = cond.value
     } else if (item.cond.__typename === 'SwitchCondPropertyBankByItemKey') {
       const cond = item.cond as SwitchCondPropertyBankByItemKey
       result.type = 'property_bank_by_item_key'
+      if (!cond.data().id)
+        throw new Error(`Invalid data reference in conds index: ${index} ${errorReference}`)
       result.key = cond.data().id
       result.value = cond.value
     } else if (item.cond.__typename === 'SwitchCondInnerStateOutlet') {
@@ -155,6 +177,8 @@ const compileSwitchConds = (templateKey, conds) =>
       const cond = item.cond as SwitchCondInnerStateCurrentCanvas
       result.type = 'inner_state'
       result.key = 'current_canvas'
+      if (!cond.value().id)
+        throw new Error(`Invalid canvas reference in conds index: ${index} ${errorReference}`)
       result.value = cond.value().id
     }
     return result
@@ -312,7 +336,10 @@ export const compile = async (app: Application) => {
               animationRunType: animationDef.runType,
               property: animationDef.property,
               type: animationTypeMap[animationDef.config.__type],
-              config: compileProperty(_.omit(animationDef.config, '__type')),
+              config: compileProperty(
+                _.omit(animationDef.config, '__type'),
+                `(animation: ${animation.id}, subspace ${subspace.id})`,
+              ),
             }
           } else if (animation.__typename === 'AnimationCompose') {
             const animationDef = animation as AnimationComposeDef
@@ -321,27 +348,49 @@ export const compile = async (app: Application) => {
               description: animationDef.description,
               animationRunType: animationDef.runType,
               compose_type: animationDef.composeType,
-              item_list: animationDef.items.map((item) => ({ animation_id: item().id })),
+              item_list: animationDef.items.map((item, index) => {
+                const animation = item()
+                if (!animation?.id)
+                  throw new Error(
+                    `Invalid animation index: ${index} (animation: ${animation.id}, subspace ${subspace.id})`,
+                  )
+                return { animation_id: animation.id }
+              }),
             }
           }
           return map
         }, {}),
         brick_map: subspace.bricks.reduce((map, brick) => {
-          const property = compileProperty(brick.property || {})
+          const property = compileProperty(
+            brick.property || {},
+            `(brick: ${brick.id}, subspace ${subspace.id})`,
+          )
           if (brick.templateKey === 'BRICK_ITEMS') {
             const brickItems = brick as BrickItems
-            const buildList = (itemBrick) => ({
+            const buildList = (itemBrick, index, key) => ({
               title: itemBrick.title,
               brickId: itemBrick.brickId,
               brickIdPrefix: itemBrick.brickIdPrefix,
               templateKey: itemBrick.templateKey,
               frame: itemBrick.frame,
-              property: compileProperty(itemBrick.property),
+              property: compileProperty(
+                itemBrick.property,
+                `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
+              ),
               propertyMapping: itemBrick.propertyMapping,
-              animation: compileAnimations(itemBrick.templateKey, itemBrick.animation || {}),
-              outlet: compileOutlets(itemBrick.templateKey, itemBrick.outlets || {}),
+              animation: compileAnimations(
+                itemBrick.templateKey,
+                itemBrick.animation || {},
+                `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
+              ),
+              outlet: compileOutlets(
+                itemBrick.templateKey,
+                itemBrick.outlets || {},
+                `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
+              ),
               eventMap: compileEvents(itemBrick.templateKey, itemBrick.eventMap || {}, {
                 camelCase: true,
+                errorReference: `(brick: ${brick.id}, ${key}: ${index}, subspace ${subspace.id})`,
               }),
               stateGroup: itemBrick.stateGroup.reduce((acc, stateGroup) => {
                 acc[stateGroup.id] = {
@@ -350,26 +399,46 @@ export const compile = async (app: Application) => {
                   override: stateGroup.override,
                   break: stateGroup.break,
                   commented: stateGroup.disabled,
-                  conds: compileSwitchConds(itemBrick.templateKey, stateGroup.conds || []),
-                  property: compileProperty(stateGroup.property),
-                  animation: compileAnimations(itemBrick.templateKey, stateGroup.animation || {}),
-                  outlet: compileOutlets(itemBrick.templateKey, stateGroup.outlets || {}),
+                  conds: compileSwitchConds(
+                    itemBrick.templateKey,
+                    stateGroup.conds || [],
+                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                  ),
+                  property: compileProperty(
+                    stateGroup.property,
+                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                  ),
+                  animation: compileAnimations(
+                    itemBrick.templateKey,
+                    stateGroup.animation || {},
+                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                  ),
+                  outlet: compileOutlets(
+                    itemBrick.templateKey,
+                    stateGroup.outlets || {},
+                    `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
+                  ),
                   eventMap: compileEvents(itemBrick.templateKey, stateGroup.eventMap || {}, {
                     camelCase: true,
+                    errorReference: `(brick: ${brick.id}, ${key}: ${index}, switch: ${stateGroup.id}, subspace ${subspace.id})`,
                   }),
                 }
                 return acc
               }, {}),
             })
             if (Array.isArray(brickItems.brickList)) {
-              const brickList = (brickItems.brickList || []).map(buildList)
+              const brickList = (brickItems.brickList || []).map((item, index) =>
+                buildList(item, index, 'brickList'),
+              )
               property.brickList = brickList
             } else {
               // Not supported Data for brickList
               throw new Error('Not supported Data for brickList directly')
             }
             if (Array.isArray(brickItems.brickDetails)) {
-              const brickDetails = (brickItems.brickDetails || []).map(buildList)
+              const brickDetails = (brickItems.brickDetails || []).map((item, index) =>
+                buildList(item, index, 'brickDetails'),
+              )
               property.brickDetails = brickDetails
             } else {
               // Not supported Data for brickList
@@ -381,9 +450,20 @@ export const compile = async (app: Application) => {
             title: brick.title,
             description: brick.description,
             property,
-            animation: compileAnimations(brick.templateKey, brick.animation || {}),
-            event_map: compileEvents(brick.templateKey, brick.events || {}),
-            outlet: compileOutlets(brick.templateKey, brick.outlets || {}),
+            animation: compileAnimations(
+              brick.templateKey,
+              brick.animation || {},
+              `(brick: ${brick.id}, subspace ${subspace.id})`,
+            ),
+            event_map: compileEvents(brick.templateKey, brick.events || {}, {
+              camelCase: false,
+              errorReference: `(brick: ${brick.id}, subspace ${subspace.id})`,
+            }),
+            outlet: compileOutlets(
+              brick.templateKey,
+              brick.outlets || {},
+              `(brick: ${brick.id}, subspace ${subspace.id})`,
+            ),
             state_group: brick.switches?.reduce((acc, switchCase) => {
               acc[switchCase.id] = {
                 title: switchCase.title,
@@ -391,11 +471,29 @@ export const compile = async (app: Application) => {
                 break: switchCase.break,
                 override: switchCase.override,
                 commented: switchCase.disabled,
-                conds: compileSwitchConds(brick.templateKey, switchCase.conds || []),
-                property: compileProperty(switchCase.property),
-                outlet: compileOutlets(brick.templateKey, switchCase.outlets || {}),
-                event_map: compileEvents(brick.templateKey, switchCase.events || {}),
-                animation: compileAnimations(brick.templateKey, switchCase.animation || {}),
+                conds: compileSwitchConds(
+                  brick.templateKey,
+                  switchCase.conds || [],
+                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                property: compileProperty(
+                  switchCase.property,
+                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                outlet: compileOutlets(
+                  brick.templateKey,
+                  switchCase.outlets || {},
+                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                event_map: compileEvents(brick.templateKey, switchCase.events || {}, {
+                  camelCase: false,
+                  errorReference: `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                }),
+                animation: compileAnimations(
+                  brick.templateKey,
+                  switchCase.animation || {},
+                  `(brick: ${brick.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
               }
               return acc
             }, {}),
@@ -407,8 +505,14 @@ export const compile = async (app: Application) => {
           map[canvas.id] = {
             title: canvas.title,
             description: canvas.description,
-            property: compileProperty(canvas.property),
-            event_map: compileEvents('CANVAS', canvas.events || {}),
+            property: compileProperty(
+              canvas.property,
+              `(canvas: ${canvas.id}, subspace ${subspace.id})`,
+            ),
+            event_map: compileEvents('CANVAS', canvas.events || {}, {
+              camelCase: false,
+              errorReference: `(canvas: ${canvas.id}, subspace ${subspace.id})`,
+            }),
             state_group: canvas.switches?.reduce((acc, switchCase) => {
               acc[switchCase.id] = {
                 title: switchCase.title,
@@ -416,21 +520,51 @@ export const compile = async (app: Application) => {
                 break: switchCase.break,
                 override: switchCase.override,
                 commented: switchCase.disabled,
-                conds: compileSwitchConds('CANVAS', switchCase.conds || []),
-                property: compileProperty(switchCase.property),
-                event_map: compileEvents('CANVAS', switchCase.events || {}),
-                animation: compileAnimations('CANVAS', switchCase.animation || {}),
+                conds: compileSwitchConds(
+                  'CANVAS',
+                  switchCase.conds || [],
+                  `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                property: compileProperty(
+                  switchCase.property,
+                  `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                event_map: compileEvents('CANVAS', switchCase.events || {}, {
+                  camelCase: false,
+                  errorReference: `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                }),
+                animation: compileAnimations(
+                  'CANVAS',
+                  switchCase.animation || {},
+                  `(canvas: ${canvas.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
               }
               return acc
             }, {}),
-            item_list: canvas.items.map((item) => ({
-              type: typeof item.item === 'function' ? 'brick' : 'subspace',
-              ...(typeof item.item === 'function'
-                ? { brick_id: (item.item as () => Brick)()?.id }
-                : { subspace_id: item.item }),
-              frame: compileFrame(item.frame),
-              hidden: item.hidden,
-            })),
+            item_list: canvas.items.map((item, index) => {
+              let itemPayload = {}
+              if (typeof item.item === 'function') {
+                const brick = (item.item as () => Brick)()
+                if (!brick?.id)
+                  throw new Error(
+                    `Invalid canvas item index: ${index}, brick not found (canvas: ${canvas.id}, subspace ${subspace.id})`,
+                  )
+                itemPayload = { brick_id: brick.id }
+              } else {
+                const subspaceId = item.item
+                if (!app.subspaces.some((s) => s.id === subspaceId))
+                  throw new Error(
+                    `Invalid canvas item index: ${index}, subspace not found (canvas: ${canvas.id}, subspace ${subspace.id})`,
+                  )
+                itemPayload = { subspace_id: subspaceId }
+              }
+              return {
+                type: typeof item.item === 'function' ? 'brick' : 'subspace',
+                ...itemPayload,
+                frame: compileFrame(item.frame),
+                hidden: item.hidden,
+              }
+            }),
           }
           return map
         }, {}),
@@ -444,9 +578,19 @@ export const compile = async (app: Application) => {
                   run_mode: generator.localSyncRunMode,
                 }
               : undefined,
-            property: compileProperty(generator.property || {}),
-            event_map: compileEvents(generator.templateKey, generator.events || {}),
-            outlet: compileOutlets(generator.templateKey, generator.outlets || {}),
+            property: compileProperty(
+              generator.property || {},
+              `(generator: ${generator.id}, subspace ${subspace.id})`,
+            ),
+            event_map: compileEvents(generator.templateKey, generator.events || {}, {
+              camelCase: false,
+              errorReference: `(generator: ${generator.id}, subspace ${subspace.id})`,
+            }),
+            outlet: compileOutlets(
+              generator.templateKey,
+              generator.outlets || {},
+              `(generator: ${generator.id}, subspace ${subspace.id})`,
+            ),
             state_group: generator.switches?.reduce((acc, switchCase) => {
               acc[switchCase.id] = {
                 title: switchCase.title,
@@ -454,11 +598,29 @@ export const compile = async (app: Application) => {
                 break: switchCase.break,
                 override: switchCase.override,
                 commented: switchCase.disabled,
-                conds: compileSwitchConds(generator.templateKey, switchCase.conds || []),
-                property: compileProperty(switchCase.property),
-                outlet: compileOutlets(generator.templateKey, switchCase.outlets || {}),
-                event_map: compileEvents(generator.templateKey, switchCase.events || {}),
-                animation: compileAnimations(generator.templateKey, switchCase.animation || {}),
+                conds: compileSwitchConds(
+                  generator.templateKey,
+                  switchCase.conds || [],
+                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                property: compileProperty(
+                  switchCase.property,
+                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                outlet: compileOutlets(
+                  generator.templateKey,
+                  switchCase.outlets || {},
+                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
+                event_map: compileEvents(generator.templateKey, switchCase.events || {}, {
+                  camelCase: false,
+                  errorReference: `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                }),
+                animation: compileAnimations(
+                  generator.templateKey,
+                  switchCase.animation || {},
+                  `(generator: ${generator.id}, switch: ${switchCase.id}, subspace ${subspace.id})`,
+                ),
               }
               return acc
             }, {}),
@@ -482,8 +644,11 @@ export const compile = async (app: Application) => {
             schema: data.schema,
             type: data.type,
             ...compileKind(data.kind),
-            value: data.value,
-            event_map: compileEvents('PROPERTY_BANK', data.events || {}),
+            value: compileProperty(data.value, `(data: ${data.id}, subspace ${subspace.id})`),
+            event_map: compileEvents('PROPERTY_BANK', data.events || {}, {
+              camelCase: false,
+              errorReference: `(data: ${data.id}, subspace ${subspace.id})`,
+            }),
           }
           return map
         }, {}),
@@ -654,8 +819,13 @@ export const compile = async (app: Application) => {
           return map
         }, {}),
         action_map: subspace.actions || undefined,
-        event_map: compileEvents('', subspace.events || {}),
-        routing: subspace.dataRouting.reduce((acc, data) => {
+        event_map: compileEvents('', subspace.events || {}, {
+          camelCase: false,
+          errorReference: `(subspace ${subspace.id})`,
+        }),
+        routing: subspace.dataRouting.reduce((acc, data, index) => {
+          if (!data?.id)
+            throw new Error(`Invalid data routing index: ${index} (subspace ${subspace.id})`)
           acc[data.id] = { enabled_routing: true }
           return acc
         }, {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.21.0-beta.16-1",
+  "version": "2.21.0-beta.17-1",
   "main": "index.ts",
   "scripts": {
     "build": "node scripts/build.js"

package/tools/pull.ts

@@ -4,9 +4,14 @@ import { pullApplicationProject, pullModuleProject } from '../api'
 
 const cwd = process.cwd()
 
-const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
-if (unstagedChanges)
-  throw new Error('Unstaged changes found, please commit or stash your changes before deploying')
+const { exitCode } = await $`cd ${cwd} && git status`.nothrow()
+const isGitRepo = exitCode === 0
+
+if (isGitRepo) {
+  const unstagedChanges = await $`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+  if (unstagedChanges)
+    throw new Error('Unstaged changes found, please commit or stash your changes before deploying')
+}
 
 const app = await Bun.file(`${cwd}/application.json`).json()
 const stage = app.stage || 'production'
@@ -15,9 +20,6 @@ const { files, lastCommitId } =
     ? await pullModuleProject(stage, app.id)
     : await pullApplicationProject(stage, app.id)
 
-const { exitCode } = await $`cd ${cwd} && git status`.nothrow()
-const isGitRepo = exitCode === 0
-
 let useMain = false
 if (isGitRepo) {
   const found = (await $`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
@@ -45,11 +47,23 @@ if (isGitRepo) {
   if (confirmContinue !== 'y') throw new Error('Pull cancelled')
 }
 
+const prettierConfig = await Bun.file(`${cwd}/.prettierrc`)
+  .json()
+  .catch(() => ({
+    trailingComma: 'all',
+    tabWidth: 2,
+    semi: false,
+    singleQuote: true,
+    printWidth: 100,
+  }))
+
 await Promise.all(
   files.map(async (file) =>
     Bun.write(
       `${cwd}/${file.name}`,
-      file.formatable ? await format(file.input, { parser: 'typescript' }) : file.input,
+      file.formatable
+        ? await format(file.input, { parser: 'typescript', ...prettierConfig })
+        : file.input,
     ),
   ),
 )