@things-factory/shell 6.0.101 → 6.0.107

package/helps/shell/attribute.md

@@ -0,0 +1,160 @@
+# Attribute
+
+Paragraphs are separated by a blank line.
+
+2nd paragraph. _Italic_, **bold**, and `monospace`. Itemized lists
+look like:
+
+- this one
+- that one
+- the other one
+
+Note that --- not considering the asterisk --- the actual text
+content starts at 4-columns in.
+
+> Block quotes are
+> written like so.
+>
+> They can span multiple paragraphs,
+> if you like.
+
+Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all
+in chapters 12--14"). Three dots ... will be converted to an ellipsis.
+Unicode is supported. ☺
+
+## An h2 header
+
+Here's a numbered list:
+
+1. first item
+2. second item
+3. third item
+
+Note again how the actual text starts at 4 columns in (4 characters
+from the left side). Here's a code sample:
+
+# Let me re-iterate ...
+
+for i in 1 .. 10 { do-something(i) }
+
+As you probably guessed, indented 4 spaces. By the way, instead of
+indenting the block, you can use delimited blocks, if you like:
+
+```
+define foobar() {
+print "Welcome to flavor country!";
+}
+```
+
+(which makes copying & pasting easier). You can optionally mark the
+delimited block for Pandoc to syntax highlight it:
+
+```python
+import time
+# Quick, count to ten!
+for i in range(10):
+# (but not *too* quick)
+time.sleep(0.5)
+print(i)
+```
+
+### An h3 header
+
+Now a nested list:
+
+1. First, get these ingredients:
+
+- carrots
+- celery
+- lentils
+
+2. Boil some water.
+
+3. Dump everything in the pot and follow
+   this algorithm:
+
+find wooden spoon
+uncover pot
+stir
+cover pot
+balance wooden spoon precariously on pot handle
+wait 10 minutes
+goto first step (or shut off burner when done)
+
+Do not bump wooden spoon or it will fall.
+
+Notice again how text always lines up on 4-space indents (including
+that last line which continues item 3 above).
+
+Here's a link to [a website](http://foo.bar), to a [local
+doc](local-doc.html), and to a [section heading in the current
+doc](#an-h2-header). Here's a footnote [^1].
+
+[^1]: Some footnote text.
+
+Tables can look like this:
+
+Name Size Material Color
+
+---
+
+All Business 9 leather brown
+Roundabout 10 hemp canvas natural
+Cinderella 11 glass transparent
+
+Table: Shoes sizes, materials, and colors.
+
+(The above is the caption for the table.) Pandoc also supports
+multi-line tables:
+
+---
+
+Keyword Text
+
+---
+
+red Sunsets, apples, and
+other red or reddish
+things.
+
+green Leaves, grass, frogs
+and other things it's
+not easy being.
+
+---
+
+A horizontal rule follows.
+
+---
+
+Here's a definition list:
+
+apples
+: Good for making applesauce.
+
+oranges
+: Citrus!
+
+tomatoes
+: There's no "e" in tomatoe.
+
+Again, text is indented 4 spaces. (Put a blank line between each
+term and its definition to spread things out more.)
+
+Here's a "line block" (note how whitespace is honored):
+
+| Line one
+| Line too
+| Line tree
+
+and images can be specified like so:
+
+![example image](example-image.jpg 'An exemplary image')
+
+Inline math equation: $\omega = d\phi / dt$. Display
+math should get its own line like so:
+
+$$I = \int \rho R^{2} dV$$
+
+And note that you can backslash-escape any punctuation characters
+which you wish to be displayed literally, ex.: \`foo\`, \*bar\*, etc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/shell",
-  "version": "6.0.101",
+  "version": "6.0.107",
   "description": "Core module for framework",
   "bin": {
     "things-factory": "bin/things-factory",
@@ -129,5 +129,5 @@
     "pg": "^8.7.3",
     "sqlite3": "^5.0.8"
   },
-  "gitHead": "c047fd44e804ee9623233fe973217570b15a1c28"
+  "gitHead": "fa6d3ad23a445081db89b26e75a696fb46a38bd6"
 }

package/server/service/attribute-set/attribute-set-item-type.ts

@@ -0,0 +1,65 @@
+import { Field, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
+import { ScalarObject } from '../common-types'
+
+export enum AttributeSetItemType {
+  number = 'number',
+  text = 'text',
+  boolean = 'boolean',
+  select = 'select',
+  date = 'date',
+  datetime = 'datetime',
+  file = 'file'
+}
+
+registerEnumType(AttributeSetItemType, {
+  name: 'AttributeSetItemType',
+  description: 'type enumeration of a attribute-set-item'
+})
+
+@ObjectType({ description: 'Entity for AttributeSetItem' })
+export class AttributeSetItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  tag?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  hidden?: boolean
+
+  @Field({ nullable: true })
+  type?: AttributeSetItemType
+
+  @Field(type => ScalarObject, { nullable: true })
+  options?: { [option: string]: any }
+}
+
+@InputType()
+export class AttributeSetItemPatch {
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  tag?: string
+
+  @Field(type => AttributeSetItemType, { nullable: true })
+  type?: AttributeSetItemType
+
+  @Field(type => ScalarObject, { nullable: true })
+  options?: { [option: string]: any }
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  hidden?: boolean
+}

package/server/service/attribute-set/attribute-set-mutation.ts

@@ -0,0 +1,125 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { AttributeSet } from './attribute-set'
+import { NewAttributeSet, AttributeSetPatch } from './attribute-set-type'
+
+@Resolver(AttributeSet)
+export class AttributeSetMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => AttributeSet, { description: 'To create new AttributeSet' })
+  async createAttributeSet(@Arg('attribute') attribute: NewAttributeSet, @Ctx() context: any): Promise<AttributeSet> {
+    const { tx } = context.state
+
+    return await tx.getRepository(AttributeSet).save({
+      ...attribute
+    })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => AttributeSet, { description: 'To modify AttributeSet information' })
+  async updateAttributeSet(
+    @Arg('id') id: string,
+    @Arg('patch') patch: AttributeSetPatch,
+    @Ctx() context: any
+  ): Promise<AttributeSet> {
+    const { tx } = context.state
+
+    const repository = tx.getRepository(AttributeSet)
+    const attribute = await repository.findOne({
+      where: { id }
+    })
+
+    return await repository.save({
+      ...attribute,
+      ...patch
+    })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => [AttributeSet], { description: "To modify multiple AttributeSets' information" })
+  async updateMultipleAttributeSet(
+    @Arg('patches', type => [AttributeSetPatch]) patches: AttributeSetPatch[],
+    @Ctx() context: any
+  ): Promise<AttributeSet[]> {
+    const { tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const attributeRepo = tx.getRepository(AttributeSet)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await attributeRepo.save({
+          ...newRecord
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const attribute = await attributeRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await attributeRepo.save({
+          ...attribute,
+          ...updateRecord
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To delete AttributeSet' })
+  async deleteAttributeSet(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { tx } = context.state
+
+    await tx.getRepository(AttributeSet).delete({ id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To delete multiple AttributeSets' })
+  async deleteAttributeSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { tx } = context.state
+
+    await tx.getRepository(AttributeSet).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To import multiple AttributeSets' })
+  async importAttributeSets(
+    @Arg('attributes', type => [AttributeSetPatch]) attributes: AttributeSetPatch[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { tx } = context.state
+
+    await Promise.all(
+      attributes.map(async (attribute: AttributeSetPatch) => {
+        await tx.getRepository(AttributeSet).save(attribute)
+      })
+    )
+
+    return true
+  }
+}

package/server/service/attribute-set/attribute-set-query.ts

@@ -0,0 +1,36 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { AttributeSet } from './attribute-set'
+import { AttributeSetList } from './attribute-set-type'
+import { ListParam } from '../common-types'
+import { getRepository } from '../../initializers/database'
+import { getQueryBuilderFromListParams } from '../../utils'
+
+@Resolver(AttributeSet)
+export class AttributeSetQuery {
+  @Query(returns => AttributeSet!, { nullable: true, description: 'To fetch a AttributeSet' })
+  async attributeSet(@Arg('id') id: string, @Ctx() context: any): Promise<AttributeSet> {
+    return await getRepository(AttributeSet).findOne({
+      where: { id }
+    })
+  }
+
+  @Query(returns => AttributeSet!, { nullable: true, description: 'To fetch a AttributeSet by Entity name' })
+  async attributeSetByEntity(@Arg('entity') entity: string, @Ctx() context: any): Promise<AttributeSet> {
+    return await getRepository(AttributeSet).findOne({
+      where: { entity }
+    })
+  }
+
+  @Query(returns => AttributeSetList, { description: 'To fetch multiple AttributeSets' })
+  async attributeSets(@Args() params: ListParam, @Ctx() context: any): Promise<AttributeSetList> {
+    const queryBuilder = getQueryBuilderFromListParams({
+      params,
+      repository: await getRepository(AttributeSet),
+      searchables: ['entity', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+}

package/server/service/attribute-set/attribute-set-type.ts

@@ -0,0 +1,46 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+
+import { AttributeSet } from './attribute-set'
+import { AttributeSetItemPatch } from './attribute-set-item-type'
+
+@InputType()
+export class NewAttributeSet {
+  @Field()
+  entity: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => [AttributeSetItemPatch], { nullable: true })
+  items?: AttributeSetItemPatch[]
+
+  @Field({ nullable: true })
+  active?: boolean
+}
+
+@InputType()
+export class AttributeSetPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  entity?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => [AttributeSetItemPatch], { nullable: true })
+  items?: AttributeSetItemPatch[]
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class AttributeSetList {
+  @Field(type => [AttributeSet])
+  items: AttributeSet[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/attribute-set/attribute-set.ts

@@ -0,0 +1,35 @@
+import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, PrimaryGeneratedColumn } from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { AttributeSetItem } from './attribute-set-item-type'
+
+@Entity()
+@Index('ix_attribute_set_0', (attributeSet: AttributeSet) => [attributeSet.entity], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for AttributeSet' })
+export class AttributeSet {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  entity: string = ''
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  description: string = ''
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => [AttributeSetItem], { nullable: true })
+  items: AttributeSetItem[]
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+}

package/server/service/attribute-set/index.ts

@@ -0,0 +1,6 @@
+import { AttributeSet } from './attribute-set'
+import { AttributeSetQuery } from './attribute-set-query'
+import { AttributeSetMutation } from './attribute-set-mutation'
+
+export const entities = [AttributeSet]
+export const resolvers = [AttributeSetQuery, AttributeSetMutation]

package/server/service/domain/domain-resolver.ts

@@ -14,7 +14,7 @@ import { DomainList, DomainPatch } from './domain-types'
 export class DomainResolver {
   @Directive('@privilege(category: "system", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
   @Query(returns => Domain, { description: 'To fetch domain' })
-  async domain(@Arg('id') id: string): Promise<Domain> {
+  async domain(@Arg('id') id: string, @Ctx() context: any): Promise<Domain> {
     const repository = getRepository(Domain)
 
     return await repository.findOneBy({ id })

package/server/service/domain/domain-types.ts

@@ -1,6 +1,6 @@
 import { ObjectType, InputType, Field, Int } from 'type-graphql'
 import { Domain } from './domain'
-import { ObjectRef } from '../common-types/object-ref'
+import { ScalarObject } from '../common-types'
 
 @InputType()
 export class DomainInput {
@@ -40,6 +40,9 @@ export class DomainPatch {
   @Field({ nullable: true })
   contentImage?: string
 
+  @Field(type => ScalarObject, { nullable: true })
+  attributes?: any
+
   @Field({ nullable: true })
   theme?: string
 }

package/server/service/domain/domain.ts

@@ -1,6 +1,7 @@
 import { Column, CreateDateColumn, Entity, Index, UpdateDateColumn } from 'typeorm'
 import { ObjectType, Field, ID } from 'type-graphql'
 import { config } from '@things-factory/env'
+import { ScalarObject } from '../common-types'
 
 const numericTypes = ['int', 'int2', 'int4', 'int8', 'integer', 'tinyint', 'smallint', 'mediumint', 'bigint']
 const generatedStrategy = ['uuid', 'rowid', 'increment', 'identity']
@@ -109,6 +110,10 @@ export class Domain {
   })
   theme: string
 
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  attributes?: any
+
   @Field({ nullable: true })
   @CreateDateColumn()
   createdAt: Date

package/server/service/index.ts

@@ -1,14 +1,11 @@
 import { transactionDirectiveResolver, transactionDirectiveTypeDefs } from './directive-transaction'
-import {
-  entities as DataEntities,
-  entities as DomainEntities,
-  resolvers as DataResolvers,
-  resolvers as DomainResolvers
-} from './domain'
+import { entities as DomainEntities, resolvers as DomainResolvers } from './domain'
+import { entities as AttributeEntities, resolvers as AttributeResolvers } from './attribute-set'
 import { resolvers as SubscriptionDataResolvers } from './subscription-data'
 
 export * from './common-types'
 export * from './domain/domain'
+export * from './domain/domain'
 
 /* EXPORT TYPES */
 export * from './domain/domain-types'
@@ -16,7 +13,7 @@ export * from './subscription-data/data-types'
 
 export const entities = [
   /* Entities */
-  ...DataEntities,
+  ...AttributeEntities,
   ...DomainEntities
 ]
 export const schema = {
@@ -25,7 +22,7 @@ export const schema = {
   },
   resolverClasses: [
     /* Resolvers */
-    ...DataResolvers,
+    ...AttributeResolvers,
     ...DomainResolvers,
     ...SubscriptionDataResolvers
   ],