@things-factory/font-base 8.0.0-beta.8 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/font-base",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,9 +24,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/attachment-base": "^8.0.0-beta.8",
-    "@things-factory/auth-base": "^8.0.0-beta.8",
-    "@things-factory/shell": "^8.0.0-beta.5"
+    "@things-factory/attachment-base": "^8.0.0",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/shell": "^8.0.0"
   },
-  "gitHead": "bf5206511b2d84dfb95edc3dae7f54f6cbb9bcca"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/controllers/google-fonts.ts

@@ -0,0 +1,28 @@
+import { config } from '@things-factory/env'
+import fetch from 'node-fetch'
+
+const address = 'https://www.googleapis.com/webfonts/v1/webfonts?key='
+
+export async function getAllGoogleFonts() {
+  var key = config.get('googleFontAPIKey')
+  if (!key) {
+    console.warn(
+      "[things-factory/font-base] Could not read API key. Please check 'googleFontAPIKey' property in your configuration."
+    )
+    return []
+  }
+  var response = await fetch(`${address}${key}`)
+  if (response.ok) {
+    return (await response.json()).items.map(font => font.family)
+  } else {
+    let errorMsg = ''
+    errorMsg += `[things-factory/font-base] ${response.status} - ${response.statusText}.`
+    switch (response.status) {
+      case 400:
+        errorMsg += '\nYour API key may be incorrect or expired.'
+        break
+    }
+    console.warn(errorMsg)
+    return []
+  }
+}

package/server/index.ts

@@ -0,0 +1,4 @@
+export * from './service'
+export * from './migrations'
+
+import './routes'

package/server/migrations/1556862253039-SeedFont.ts

@@ -0,0 +1,39 @@
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { Font } from '../service/font/font'
+
+const SEED_FONTS = ['Roboto', 'Pangolin', 'Railway', 'Slabo', 'Skranji']
+
+export class seedFonts1556862253039 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<any> {
+    const repository = getRepository(Font)
+    const domainRepository = getRepository(Domain)
+    const domain = await domainRepository.findOneBy({
+      name: 'SYSTEM'
+    })
+
+    return await Promise.all(
+      SEED_FONTS.map(async font => {
+        await repository.save({
+          name: font,
+          domain,
+          provider: 'google',
+          uri: '',
+          path: '',
+          active: true
+        })
+      })
+    )
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<any> {
+    const repository = getRepository(Font)
+
+    SEED_FONTS.reverse().forEach(async font => {
+      let record = await repository.findOneBy({ name: font })
+      await repository.remove(record)
+    })
+  }
+}

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/routes.ts

@@ -0,0 +1,8 @@
+import { getAllGoogleFonts } from './controllers/google-fonts'
+
+process.on('bootstrap-module-global-public-route' as any, (app, routes) => {
+  routes.get('/all-google-fonts', async (context, next) => {
+    context.type = 'application/json'
+    context.body = await getAllGoogleFonts()
+  })
+})

package/server/service/font/font-mutation.ts

@@ -0,0 +1,126 @@
+import { Arg, Ctx, Mutation, Resolver, Root } from 'type-graphql'
+
+import { createAttachments, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+import { getRepository, pubsub } from '@things-factory/shell'
+
+import { Font } from './font'
+import { FontPatch, NewFont } from './font-type'
+
+function notifyChanges(event, domain, font) {
+  const { name, provider, uri, path, active } = font
+  const { subdomain } = domain
+  pubsub.publish('notify-font-changed', {
+    event,
+    font: {
+      domain: {
+        subdomain
+      },
+      name,
+      provider,
+      uri,
+      path,
+      active
+    }
+  })
+}
+@Resolver(Font)
+export class FontMutation {
+  @Mutation(returns => Font, { description: 'To create new Font' })
+  async createFont(@Root() _, @Arg('font') font: NewFont, @Ctx() context: ResolverContext): Promise<Font> {
+    const { domain, user } = context.state
+
+    const repository = getRepository(Font)
+
+    const created = await repository.save({
+      domain,
+      creator: user,
+      updater: user,
+      ...font
+    })
+
+    if (font.files) {
+      await createAttachments(
+        _,
+        {
+          attachments: font.files.map(file => {
+            return {
+              file,
+              refType: Font.name,
+              refBy: created.id
+            }
+          })
+        },
+        context
+      )
+    }
+
+    notifyChanges('created', domain, created)
+
+    return created
+  }
+
+  @Mutation(returns => Font, { description: 'To modify Font information' })
+  async updateFont(
+    @Root() _,
+    @Arg('id') id: string,
+    @Arg('patch') patch: FontPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Font> {
+    const { domain, user } = context.state
+
+    const repository = getRepository(Font)
+    const font = await repository.findOne({
+      where: {
+        domain: { id: domain.id },
+        id
+      }
+    })
+
+    const updated = await repository.save({
+      ...font,
+      ...patch,
+      updater: user
+    })
+
+    if (patch.files) {
+      await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+      await createAttachments(
+        _,
+        {
+          attachments: patch.files.map(file => {
+            return {
+              file,
+              refType: Font.name,
+              refBy: updated.id
+            }
+          })
+        },
+        context
+      )
+    }
+
+    notifyChanges('updated', domain, updated)
+
+    return updated
+  }
+
+  @Mutation(returns => Boolean, { description: 'To delete Font' })
+  async deleteFont(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain } = context.state
+
+    const repository = getRepository(Font)
+    const font = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    if (font) {
+      await repository.remove(font)
+    }
+
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    notifyChanges('removed', domain, font)
+
+    return true
+  }
+}

package/server/service/font/font-query.ts

@@ -0,0 +1,62 @@
+import { In } from 'typeorm'
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Font } from './font'
+import { FontList } from './font-type'
+
+@Resolver(Font)
+export class FontQuery {
+  @Query(returns => Font, { description: 'To fetch a Font' })
+  async font(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Font> {
+    const { domain } = context.state
+
+    return await getRepository(Font).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
+    })
+  }
+
+  @Query(returns => FontList, { description: 'To fetch multiple Fonts' })
+  async fonts(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<FontList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(Font),
+      params,
+      domain,
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() font: Font) {
+    return await getRepository(Domain).findOneBy({ id: font.domainId })
+  }
+
+  @FieldResolver(type => Attachment)
+  async files(@Root() font: Font, @Ctx() context: ResolverContext) {
+    const { domain } = context.state
+
+    return await getRepository(Attachment).findBy({
+      domain: { id: domain.id },
+      refBy: font.id
+    })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() font: Font): Promise<User> {
+    return await getRepository(User).findOneBy({ id: font.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() font: Font): Promise<User> {
+    return await getRepository(User).findOneBy({ id: font.creatorId })
+  }
+}

package/server/service/font/font-type.ts

@@ -0,0 +1,56 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Font } from './font'
+
+@InputType()
+export class NewFont {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  provider?: string
+
+  @Field({ nullable: true })
+  uri?: string
+
+  @Field({ nullable: true })
+  path?: string
+
+  @Field(type => [GraphQLUpload], { nullable: true })
+  files?: FileUpload[]
+
+  @Field({ nullable: true })
+  active?: boolean
+}
+
+@InputType()
+export class FontPatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  provider?: string
+
+  @Field({ nullable: true })
+  uri?: string
+
+  @Field({ nullable: true })
+  path?: string
+
+  @Field(type => [GraphQLUpload], { nullable: true })
+  files?: FileUpload[]
+
+  @Field({ nullable: true })
+  active?: boolean
+}
+
+@ObjectType()
+export class FontList {
+  @Field(type => [Font])
+  items: Font[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/font/font.ts

@@ -0,0 +1,84 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index('ix_font_0', (font: Font) => [font.domain, font.name], { unique: true })
+@ObjectType({ description: 'Entity for Font' })
+export class Font {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((font: Font) => font.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column()
+  @Field()
+  provider: string // custom, typekit, google,
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  uri?: string // For typekit, custom,
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  path?: string // Uploaded path for custom
+
+  @Column()
+  @Field()
+  active: boolean
+
+  @Field(type => [Attachment], { nullable: true })
+  files?: Attachment[]
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((font: Font) => font.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((font: Font) => font.updater)
+  updaterId?: string
+}

package/server/service/font/index.ts

@@ -0,0 +1,6 @@
+import { Font } from './font'
+import { FontQuery } from './font-query'
+import { FontMutation } from './font-mutation'
+
+export const entities = [Font]
+export const resolvers = [FontQuery, FontMutation]

package/server/service/index.ts

@@ -0,0 +1,20 @@
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as FontEntities, resolvers as FontResolvers } from './font'
+
+/* EXPORT ENTITY TYPES */
+export * from './font/font'
+
+/* EXPORT TYPES */
+export * from './font/font-type'
+
+export const entities = [
+  /* ENTITIES */
+  ...FontEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...FontResolvers
+  ]
+}