wip: rename

Author: arpowers

.pnpmfile.cjs

@@ -1,21 +1,21 @@
 // const fs = require('node:fs')
 // const path = require('node:path')
 
-// const exists = fs.existsSync(path.join(process.cwd(), '../factor/package.json'))
+// const exists = fs.existsSync(path.join(process.cwd(), '../fiction/package.json'))
 // const localInstall = process.env.INSTALL_ENV === 'local'
-function rewriteFactorDependency(deps) {
+function rewriteFictionDependency(deps) {
   // Object.entries(deps).forEach(([name, version]) => {
   //   if (name.includes("@fiction")) {
   //     deps[name] =
-  //       exists && localInstall ? `file:~/Projects/factor/${name}` : "latest"
+  //       exists && localInstall ? `file:~/Projects/fiction/${name}` : "latest"
   //   }
   // })
   return deps
 }
 
 function readPackage(pkg, _context) {
-  pkg.dependencies = rewriteFactorDependency(pkg.dependencies)
-  pkg.devDependencies = rewriteFactorDependency(pkg.devDependencies)
+  pkg.dependencies = rewriteFictionDependency(pkg.dependencies)
+  pkg.devDependencies = rewriteFictionDependency(pkg.devDependencies)
 
   return pkg
 }

.prettierignore

@@ -1,11 +1,11 @@
 import { vue } from './utils'
-import type { FactorApp } from './plugin-app'
-import type { FactorRouter } from './plugin-router'
-import type { FactorUser } from './plugin-user'
-import type { FactorEnv, ServiceList } from './plugin-env'
-import type { FactorMedia } from './plugin-media'
-import type { FactorDb } from './plugin-db'
-import type { FactorServer } from './plugin-server'
+import type { FictionApp } from './plugin-app'
+import type { FictionRouter } from './plugin-router'
+import type { FictionUser } from './plugin-user'
+import type { FictionEnv, ServiceList } from './plugin-env'
+import type { FictionMedia } from './plugin-media'
+import type { FictionDb } from './plugin-db'
+import type { FictionServer } from './plugin-server'
 
 export type RunVars = {
   APP_INSTANCE: string
@@ -32,13 +32,13 @@ export type RunVars = {
 }
 
 export type StandardServices = {
-  factorRouter: FactorRouter
-  factorUser: FactorUser
-  factorEnv: FactorEnv
-  factorApp: FactorApp
-  factorMedia: FactorMedia
-  factorDb: FactorDb
-  factorServer: FactorServer
+  fictionRouter: FictionRouter
+  fictionUser: FictionUser
+  fictionEnv: FictionEnv
+  fictionApp: FictionApp
+  fictionMedia: FictionMedia
+  fictionDb: FictionDb
+  fictionServer: FictionServer
   runVars?: RunVars
 } & ServiceList
 

.prettierrc

@@ -1,6 +1,6 @@
 {
   "bin": {
-    "factor": "./plugin-env/cli.js"
+    "fiction": "./plugin-env/cli.js"
   },
   "buildOptions": [
     {
@@ -137,7 +137,7 @@
   },
   "devDependencies": {
     "@babel/parser": "^7.24.0",
-    "@playwright/test": "^1.42.0",
+    "@playwright/test": "^1.42.1",
     "@tailwindcss/forms": "^0.5.7",
     "@types/bcrypt": "^5.0.2",
     "@types/body-parser": "^1.19.5",
@@ -169,7 +169,7 @@
     "deep-object-diff": "^1.1.9",
     "fake-indexeddb": "^5.0.2",
     "ngrok": "5.0.0-beta.2",
-    "playwright": "^1.42.0",
+    "playwright": "^1.42.1",
     "react-dom": "^18.2.0",
     "rollup": "^4.12.0",
     "util": "^0.12.5",

docker/clickhouse/clickhouse-config.xml .ref/clickhouse/clickhouse-config.xml

@@ -6,26 +6,26 @@ import type { Express } from 'express'
 import { createHead } from '@unhead/vue'
 import type { HookType } from '../utils'
 import { initializeResetUi, safeDirname, vue } from '../utils'
-import type { FactorAppEntry, FactorEnv, ServiceConfig, ServiceList } from '../plugin-env'
-import { FactorPlugin } from '../plugin'
-import type { FactorBuild } from '../plugin-build'
-import type { FactorRouter } from '../plugin-router'
+import type { FictionAppEntry, FictionEnv, ServiceConfig, ServiceList } from '../plugin-env'
+import { FictionPlugin } from '../plugin'
+import type { FictionBuild } from '../plugin-build'
+import type { FictionRouter } from '../plugin-router'
 import type { RunVars, StandardServices } from '../inject'
-import { FactorRender } from './plugin-render'
+import { FictionRender } from './plugin-render'
 import ElRoot from './ElRoot.vue'
-import type { FactorSitemap } from './sitemap'
+import type { FictionSitemap } from './sitemap'
 import type { SiteMapEntry } from './types'
 
 type HookDictionary = {
-  beforeAppMounted: { args: [FactorAppEntry] }
-  appMounted: { args: [FactorAppEntry] }
+  beforeAppMounted: { args: [FictionAppEntry] }
+  appMounted: { args: [FictionAppEntry] }
   afterAppSetup: { args: [{ service: ServiceList }] }
   viteConfig: { args: [vite.InlineConfig[]] }
   headTags: { args: [string, { pathname?: string }] }
   htmlBody: { args: [string, { pathname?: string }] }
 }
 
-export interface FactorAppSettings {
+export interface FictionAppSettings {
   hooks?: HookType<HookDictionary>[]
   mode?: 'production' | 'development'
   isTest?: boolean
@@ -34,9 +34,9 @@ export interface FactorAppSettings {
   isLive?: vue.Ref<boolean>
   altHostnames?: { dev: string, prod: string }[]
   port: number
-  factorEnv: FactorEnv
+  fictionEnv: FictionEnv
   rootComponent?: vue.Component
-  factorRouter: FactorRouter
+  fictionRouter: FictionRouter
   sitemaps?: SiteMapEntry[]
   uiPaths?: string[]
   tailwindConfig?: Partial<TailwindConfig>[]
@@ -47,18 +47,18 @@ export interface FactorAppSettings {
   [key: string]: unknown
 }
 
-export class FactorApp extends FactorPlugin<FactorAppSettings> {
-  isLive = this.settings.isLive ?? this.settings.factorEnv.isProd
+export class FictionApp extends FictionPlugin<FictionAppSettings> {
+  isLive = this.settings.isLive ?? this.settings.fictionEnv.isProd
   viteDevServer?: vite.ViteDevServer
   hooks = this.settings.hooks ?? []
   uiPaths = this.settings.uiPaths ?? []
-  factorRouter = this.settings.factorRouter
+  fictionRouter = this.settings.fictionRouter
   isTest = this.settings.isTest || this.utils.isTest()
   rootComponent = this.settings.rootComponent || ElRoot
-  factorEnv = this.settings.factorEnv
-  factorBuild?: FactorBuild
-  factorSitemap?: FactorSitemap
-  factorRender?: FactorRender
+  fictionEnv = this.settings.fictionEnv
+  fictionBuild?: FictionBuild
+  fictionSitemap?: FictionSitemap
+  fictionRender?: FictionRender
   appName: string
   appEmail: string
   sitemaps = this.settings.sitemaps ?? []
@@ -73,49 +73,49 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
     return isLive ? this.liveUrl.value : this.localUrl
   })
 
-  srcFolder = this.settings.srcFolder || this.factorEnv.cwd
+  srcFolder = this.settings.srcFolder || this.fictionEnv.cwd
   mainIndexHtml = this.settings.mainIndexHtml || path.join(this.srcFolder, 'index.html')
   publicFolder = this.settings.publicFolder || path.join(this.srcFolder, 'public')
 
   appInstanceId = this.settings.appInstanceId || 'app'
   root = safeDirname(import.meta.url)
 
-  constructor(settings: FactorAppSettings) {
+  constructor(settings: FictionAppSettings) {
     super('app', settings)
 
-    this.appEmail = this.factorEnv.appEmail
-    this.appName = this.factorEnv.appName
+    this.appEmail = this.fictionEnv.appEmail
+    this.appName = this.fictionEnv.appName
     /**
      * node application init
      */
-    if (!this.factorEnv.isApp.value && this.factorEnv?.cwd) {
-      this.factorRender = new FactorRender({
-        factorApp: this,
-        factorEnv: this.factorEnv,
-        factorRouter: this.factorRouter,
+    if (!this.fictionEnv.isApp.value && this.fictionEnv?.cwd) {
+      this.fictionRender = new FictionRender({
+        fictionApp: this,
+        fictionEnv: this.fictionEnv,
+        fictionRouter: this.fictionRouter,
       })
     }
 
     this.addSchema()
   }
 
   addSchema() {
-    if (this.factorEnv) {
-      this.factorEnv.addHook({
+    if (this.fictionEnv) {
+      this.fictionEnv.addHook({
         hook: 'staticSchema',
         callback: async (existing) => {
-          const routeKeys = this.factorRouter.routes.value?.map(_ => _.name).filter(Boolean).sort()
+          const routeKeys = this.fictionRouter.routes.value?.map(_ => _.name).filter(Boolean).sort()
 
           return { ...existing, routes: { enum: routeKeys, type: 'string' }, menus: { enum: [''], type: 'string' } }
         },
       })
 
-      this.factorEnv.addHook({
+      this.fictionEnv.addHook({
         hook: 'staticConfig',
         callback: (
           schema: Record<string, unknown>,
         ): Record<string, unknown> => {
-          return { ...schema, routes: this.factorRouter.routes.value?.map(ep => ({ key: ep.name, path: ep.path })) }
+          return { ...schema, routes: this.fictionRouter.routes.value?.map(ep => ({ key: ep.name, path: ep.path })) }
         },
       })
     }
@@ -139,28 +139,28 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
   }
 
   async buildApp(options: { render?: boolean, serve?: boolean } = {}) {
-    if (this.factorEnv.isApp.value)
+    if (this.fictionEnv.isApp.value)
       return
-    return this.factorRender?.buildApp(options)
+    return this.fictionRender?.buildApp(options)
   }
 
   async serveStaticApp() {
-    if (this.factorEnv.isApp.value)
+    if (this.fictionEnv.isApp.value)
       return
-    return this.factorRender?.serveStaticApp()
+    return this.fictionRender?.serveStaticApp()
   }
 
   createVueApp = async (args: {
     renderRoute?: string
     runVars?: Partial<RunVars>
     service: ServiceList & Partial<StandardServices>
-  }): Promise<FactorAppEntry> => {
+  }): Promise<FictionAppEntry> => {
     const { renderRoute, service, runVars } = args
 
-    const router = this.factorRouter.create({ caller: `mountApp:${this.appInstanceId}` })
+    const router = this.fictionRouter.create({ caller: `mountApp:${this.appInstanceId}` })
 
     if (renderRoute)
-      await this.factorRouter.replace({ path: renderRoute }, { id: 'mount' })
+      await this.fictionRouter.replace({ path: renderRoute }, { id: 'mount' })
 
     await this.utils.runHooks<HookDictionary, 'afterAppSetup'>({
       list: this.hooks,
@@ -172,8 +172,8 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
       ? vue.createSSRApp(this.rootComponent)
       : vue.createApp(this.rootComponent)
 
-    this.factorEnv.service.value = { ...this.factorEnv.service.value, ...service, runVars }
-    app.provide('service', this.factorEnv.service)
+    this.fictionEnv.service.value = { ...this.fictionEnv.service.value, ...service, runVars }
+    app.provide('service', this.fictionEnv.service)
 
     app.use(router)
 
@@ -193,14 +193,14 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
     runVars?: Partial<RunVars>
     service: ServiceList & Partial<StandardServices>
     serviceConfig?: ServiceConfig
-  }): Promise<FactorAppEntry> {
+  }): Promise<FictionAppEntry> {
     const { selector = '#app', renderRoute, service, runVars, serviceConfig } = args
 
-    await this.factorEnv.crossRunCommand({ context: 'app', serviceConfig, runVars })
+    await this.fictionEnv.crossRunCommand({ context: 'app', serviceConfig, runVars })
 
     const entry = await this.createVueApp({ renderRoute, runVars, service })
 
-    if (typeof window !== 'undefined' && !this.factorEnv.isSSR.value) {
+    if (typeof window !== 'undefined' && !this.fictionEnv.isSSR.value) {
       await this.utils.runHooks<HookDictionary, 'beforeAppMounted'>({
         list: this.hooks,
         hook: 'beforeAppMounted',
@@ -212,7 +212,7 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
       if (!mountEl)
         throw new Error(`mountEl not found: ${selector}`)
 
-      initializeResetUi(this.factorRouter).catch(console.error)
+      initializeResetUi(this.fictionRouter).catch(console.error)
       entry.app.mount(mountEl)
 
       document.documentElement.style.opacity = '1'
@@ -250,11 +250,11 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
   async ssrServerSetup(
     args: { isProd?: boolean, expressApp?: Express } = {},
   ): Promise<Express | undefined> {
-    if (this.factorEnv.isApp.value || !this.factorRender)
+    if (this.fictionEnv.isApp.value || !this.fictionRender)
       return
 
     const { isProd = false, expressApp } = args
-    const eApp = await this.factorRender.createExpressApp({ isProd, expressApp })
+    const eApp = await this.fictionRender.createExpressApp({ isProd, expressApp })
 
     return eApp
   }
@@ -263,11 +263,11 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
    * This creates an endpoint server and ssr server on same port
    * Allows production apps to serve on one instance
    */
-  // async comboSsrServerCreate(args: { isProd?: boolean, factorServer: FactorServer, factorUser: FactorUser }) {
-  //   const { isProd = false, factorServer, factorUser } = args
-  //   factorServer.port.value = this.port
-  //   factorServer.useLocal.value = true
-  //   const srv = await factorServer.initServer({ factorUser })
+  // async comboSsrServerCreate(args: { isProd?: boolean, fictionServer: FictionServer, fictionUser: FictionUser }) {
+  //   const { isProd = false, fictionServer, fictionUser } = args
+  //   fictionServer.port.value = this.port
+  //   fictionServer.useLocal.value = true
+  //   const srv = await fictionServer.initServer({ fictionUser })
   //   await this.ssrServerSetup({ isProd, expressApp: srv?.expressApp })
   //   await srv?.run()
   //   this.logReady({ serveMode: 'comboSSR' })
@@ -277,7 +277,7 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
     args: { isProd?: boolean, expressApp?: Express } = {},
   ): Promise<http.Server | undefined> {
     const { isProd = false, expressApp } = args
-    if (this.factorEnv.isApp.value || !this.factorRender)
+    if (this.fictionEnv.isApp.value || !this.fictionRender)
       return
 
     const eApp = await this.ssrServerSetup({ isProd, expressApp })
@@ -295,6 +295,6 @@ export class FactorApp extends FactorPlugin<FactorAppSettings> {
     this.log.info('close app')
     this.appServer?.close()
     this.staticServer?.close()
-    await this.factorRender?.viteDevServer?.close()
+    await this.fictionRender?.viteDevServer?.close()
   }
 }