UBER-174: Introduce createOn every there

dev/generator/src/issues.ts

@@ -35,8 +35,7 @@ const object: AttachedData<Issue> = {
   reportedTime: 0,
   estimation: 0,
   reports: 0,
-  childInfo: [],
-  createOn: Date.now()
+  childInfo: []
 }
 
 export interface IssueOptions {
@@ -98,8 +97,7 @@ async function genIssue (client: TxOperations, statuses: Ref<IssueStatus>[]): Pr
     estimation: object.estimation,
     reports: 0,
     relations: [],
-    childInfo: [],
-    createOn: Date.now()
+    childInfo: []
   }
   await client.addCollection(
     tracker.class.Issue,

dev/generator/src/recruit.ts

@@ -2,23 +2,23 @@ import contact, { Channel, Employee, EmployeeAccount, Person } from '@hcengineer
 import core, {
   AttachedData,
   Data,
-  generateId,
   MeasureContext,
   MeasureMetricsContext,
-  metricsToString,
   MixinUpdate,
   Ref,
   TxOperations,
-  WorkspaceId
+  WorkspaceId,
+  generateId,
+  metricsToString
 } from '@hcengineering/core'
 import { MinioService } from '@hcengineering/minio'
 import recruit from '@hcengineering/model-recruit'
 import { Applicant, Candidate, Vacancy } from '@hcengineering/recruit'
-import { genRanks, State } from '@hcengineering/task'
+import { State, genRanks } from '@hcengineering/task'
 import faker from 'faker'
 import jpeg, { BufferRet } from 'jpeg-js'
-import { addAttachments, AttachmentOptions } from './attachments'
-import { addComments, CommentOptions } from './comments'
+import { AttachmentOptions, addAttachments } from './attachments'
+import { CommentOptions, addComments } from './comments'
 import { connect } from './connect'
 import { createUpdateSpaceKanban } from './kanban'
 import { findOrUpdate, findOrUpdateAttached } from './utils'
@@ -162,8 +162,7 @@ async function genApplicant (
     doneState: null,
     rank: rank as string,
     startDate: null,
-    dueDate: null,
-    createOn: Date.now()
+    dueDate: null
   }
 
   // Update or create candidate
@@ -234,8 +233,7 @@ async function genCandidate (
   const candidate: Data<Person> = {
     name: fName + ',' + lName,
     city: faker.address.city(),
-    avatar: imgId,
-    createOn: Date.now()
+    avatar: imgId
   }
 
   const candidateMixin: MixinUpdate<Person, Candidate> = {

models/chunter/src/index.ts

@@ -91,10 +91,6 @@ export class TChunterMessage extends TAttachedDoc implements ChunterMessage {
   @ReadOnly()
     createBy!: Ref<Account>
 
-  @Prop(TypeTimestamp(), chunter.string.Create)
-  @ReadOnly()
-    createOn!: Timestamp
-
   @Prop(TypeTimestamp(), chunter.string.Edit)
     editedOn?: Timestamp
 

models/chunter/src/migration.ts

@@ -14,7 +14,7 @@
 //
 
 import { Comment, Message, ThreadMessage } from '@hcengineering/chunter'
-import core, { Doc, DOMAIN_TX, Ref, TxCreateDoc, TxOperations } from '@hcengineering/core'
+import core, { DOMAIN_TX, Doc, Ref, TxCreateDoc, TxOperations } from '@hcengineering/core'
 import { MigrateOperation, MigrationClient, MigrationUpgradeClient } from '@hcengineering/model'
 import { DOMAIN_CHUNTER, DOMAIN_COMMENT } from './index'
 import chunter from './plugin'
@@ -81,21 +81,6 @@ async function createBacklink (tx: TxOperations): Promise<void> {
   }
 }
 
-export async function setCreate (client: TxOperations): Promise<void> {
-  const messages = (await client.findAll(chunter.class.Message, {}))
-    .filter((m) => m.createBy === undefined)
-    .map((m) => m._id)
-  if (messages.length === 0) return
-  const txes = await client.findAll(core.class.TxCreateDoc, { objectId: { $in: messages } })
-  const promises = txes.map(async (tx) => {
-    await client.updateDoc<Message>(chunter.class.Message, tx.objectSpace, tx.objectId as Ref<Message>, {
-      createBy: tx.modifiedBy,
-      createOn: tx.modifiedOn
-    })
-  })
-  await Promise.all(promises)
-}
-
 export async function migrateMessages (client: MigrationClient): Promise<void> {
   const messages = await client.find(DOMAIN_CHUNTER, {
     _class: chunter.class.Message,
@@ -188,6 +173,5 @@ export const chunterOperation: MigrateOperation = {
     await createGeneral(tx)
     await createRandom(tx)
     await createBacklink(tx)
-    await setCreate(tx)
   }
 }

models/contact/src/index.ts

@@ -40,7 +40,6 @@ import {
   Index,
   Model,
   Prop,
-  ReadOnly,
   TypeDate,
   TypeRef,
   TypeString,
@@ -103,10 +102,6 @@ export class TContact extends TDoc implements Contact {
   @Prop(TypeString(), contact.string.Location)
   @Index(IndexKind.FullText)
     city!: string
-
-  @Prop(TypeTimestamp(), contact.string.CreatedDate)
-  @ReadOnly()
-    createOn!: Timestamp
 }
 
 @Model(contact.class.Channel, core.class.AttachedDoc, DOMAIN_CHANNEL)

models/contact/src/migration.ts

@@ -1,10 +1,9 @@
 //
 
-import { Contact } from '@hcengineering/contact'
-import { DOMAIN_TX, TxCreateDoc, TxOperations } from '@hcengineering/core'
+import { TxOperations } from '@hcengineering/core'
 import { MigrateOperation, MigrationClient, MigrationUpgradeClient } from '@hcengineering/model'
 import core from '@hcengineering/model-core'
-import contact, { DOMAIN_CONTACT } from './index'
+import contact from './index'
 
 async function createSpace (tx: TxOperations): Promise<void> {
   const current = await tx.findOne(core.class.Space, {
@@ -43,64 +42,6 @@ async function createSpace (tx: TxOperations): Promise<void> {
   }
 }
 
-let totalCreateOn = 0
-async function setCreate (client: MigrationClient): Promise<void> {
-  while (true) {
-    const docs = await client.find<Contact>(
-      DOMAIN_CONTACT,
-      {
-        _class: {
-          $in: [contact.class.Contact, contact.class.Organization, contact.class.Person, contact.class.Employee]
-        },
-        createOn: { $exists: false }
-      },
-      { limit: 500 }
-    )
-    if (docs.length === 0) {
-      break
-    }
-    totalCreateOn += docs.length
-    console.log('processing createOn migration', totalCreateOn)
-    const creates = await client.find<TxCreateDoc<Contact>>(DOMAIN_TX, {
-      objectId: { $in: docs.map((it) => it._id) },
-      _class: core.class.TxCreateDoc
-    })
-    for (const doc of docs) {
-      const tx = creates.find((it) => it.objectId === doc._id)
-      if (tx !== undefined) {
-        await client.update(
-          DOMAIN_CONTACT,
-          {
-            _id: doc._id
-          },
-          {
-            createOn: tx.modifiedOn
-          }
-        )
-        await client.update(
-          DOMAIN_TX,
-          {
-            _id: tx._id
-          },
-          {
-            'attributes.createOn': tx.modifiedOn
-          }
-        )
-      } else {
-        await client.update(
-          DOMAIN_CONTACT,
-          {
-            _id: doc._id
-          },
-          {
-            createOn: doc.modifiedOn
-          }
-        )
-      }
-    }
-  }
-}
-
 async function createEmployeeEmail (client: TxOperations): Promise<void> {
   const employees = await client.findAll(contact.class.Employee, {})
   const channels = await client.findAll(contact.class.Channel, {
@@ -133,9 +74,7 @@ async function createEmployeeEmail (client: TxOperations): Promise<void> {
 }
 
 export const contactOperation: MigrateOperation = {
-  async migrate (client: MigrationClient): Promise<void> {
-    await setCreate(client)
-  },
+  async migrate (client: MigrationClient): Promise<void> {},
   async upgrade (client: MigrationUpgradeClient): Promise<void> {
     const tx = new TxOperations(client, core.account.System)
     await createSpace(tx)

models/core/src/core.ts

@@ -57,6 +57,7 @@ import {
   Mixin as MMixin,
   Model,
   Prop,
+  ReadOnly,
   TypeBoolean,
   TypeIntlString,
   TypeRecord,
@@ -101,6 +102,10 @@ export class TDoc extends TObj implements Doc {
   @Prop(TypeRef(core.class.Account), core.string.CreatedBy)
   @Index(IndexKind.Indexed)
     createdBy!: Ref<Account>
+
+  @Prop(TypeTimestamp(), core.string.CreatedDate)
+  @ReadOnly()
+    createOn!: Timestamp
 }
 
 @Model(core.class.AttachedDoc, core.class.Doc)

models/core/src/migration.ts

@@ -13,17 +13,17 @@
 // limitations under the License.
 //
 
-import { MigrateOperation, MigrationClient, MigrationUpgradeClient } from '@hcengineering/model'
 import core, {
-  Doc,
+  AttachedDoc,
   DOMAIN_BLOB,
   DOMAIN_DOC_INDEX_STATE,
   DOMAIN_MODEL,
   DOMAIN_TX,
-  TxCreateDoc,
+  Doc,
   TxCollectionCUD,
-  AttachedDoc
+  TxCreateDoc
 } from '@hcengineering/core'
+import { MigrateOperation, MigrationClient, MigrationUpgradeClient } from '@hcengineering/model'
 
 async function fillCreatedBy (client: MigrationClient): Promise<void> {
   const h = client.hierarchy
@@ -87,9 +87,72 @@ async function fillCreatedBy (client: MigrationClient): Promise<void> {
     }
   }
 }
+async function fillCreatedOn (client: MigrationClient): Promise<void> {
+  const h = client.hierarchy
+  const domains = h.domains()
+  for (const domain of domains) {
+    if (
+      domain === DOMAIN_TX ||
+      domain === DOMAIN_MODEL ||
+      domain === DOMAIN_BLOB ||
+      domain === DOMAIN_DOC_INDEX_STATE
+    ) {
+      continue
+    }
+    while (true) {
+      try {
+        const objects = await client.find<Doc>(
+          domain,
+          { createdOn: { $exists: false } },
+          { projection: { _id: 1, modifiedOn: 1 }, limit: 10000 }
+        )
+        if (objects.length === 0) {
+          break
+        }
+        const txes = await client.find<TxCreateDoc<Doc>>(
+          DOMAIN_TX,
+          {
+            _class: core.class.TxCreateDoc,
+            objectId: { $in: Array.from(objects.map((it) => it._id)) }
+          },
+          { projection: { _id: 1, modifiedOn: 1, createOn: 1, objectId: 1 } }
+        )
+
+        const txes2 = (
+          await client.find<TxCollectionCUD<Doc, AttachedDoc>>(
+            DOMAIN_TX,
+            {
+              _class: core.class.TxCollectionCUD,
+              'tx._class': core.class.TxCreateDoc,
+              'tx.objectId': { $in: Array.from(objects.map((it) => it._id)) }
+            },
+            { projection: { _id: 1, modifiedOn: 1, createOn: 1, tx: 1 } }
+          )
+        ).map((it) => it.tx as unknown as TxCreateDoc<Doc>)
+
+        const txMap = new Map(txes.concat(txes2).map((p) => [p.objectId, p]))
+
+        console.log('migrateCreateOn', domain, objects.length)
+        await client.bulk(
+          domain,
+          objects.map((it) => {
+            const createTx = txMap.get(it._id)
+            return {
+              filter: { _id: it._id },
+              update: {
+                createdOn: createTx?.createOn ?? it.modifiedOn
+              }
+            }
+          })
+        )
+      } catch (err) {}
+    }
+  }
+}
 export const coreOperation: MigrateOperation = {
   async migrate (client: MigrationClient): Promise<void> {
     await fillCreatedBy(client)
+    await fillCreatedOn(client)
   },
   async upgrade (client: MigrationUpgradeClient): Promise<void> {}
 }

models/demo/src/migration.ts

@@ -13,11 +13,11 @@
 // limitations under the License.
 //
 
+import contact, { EmployeeAccount } from '@hcengineering/contact'
 import core, { AccountRole, DOMAIN_TX, TxCreateDoc, TxOperations } from '@hcengineering/core'
 import { MigrateOperation, MigrationClient, MigrationUpgradeClient } from '@hcengineering/model'
-import contact, { EmployeeAccount } from '@hcengineering/contact'
-import recruit from '@hcengineering/model-recruit'
 import { DOMAIN_CONTACT } from '@hcengineering/model-contact'
+import recruit from '@hcengineering/model-recruit'
 
 async function createCandidate (
   tx: TxOperations,
@@ -33,8 +33,7 @@ async function createCandidate (
   if (current !== undefined) return
   const u1 = await tx.createDoc(contact.class.Person, recruit.space.CandidatesPublic, {
     name,
-    city,
-    createOn: Date.now()
+    city
   })
   await tx.addCollection(contact.class.Channel, recruit.space.CandidatesPublic, u1, contact.class.Person, 'channels', {
     provider: contact.channelProvider.Email,
@@ -74,8 +73,7 @@ export const demoOperation: MigrateOperation = {
       const employee = await ops.createDoc(contact.class.Employee, contact.space.Employee, {
         name: 'Chen,Rosamund',
         city: 'Mountain View',
-        active: true,
-        createOn: Date.now()
+        active: true
       })
 
       await ops.createDoc<EmployeeAccount>(contact.class.EmployeeAccount, core.space.Model, {

models/lead/src/index.ts

@@ -270,6 +270,7 @@ export function createModel (builder: Builder): void {
     orderBy: [
       ['state', SortingOrder.Ascending],
       ['modifiedOn', SortingOrder.Descending],
+      ['createOn', SortingOrder.Descending],
       ['dueDate', SortingOrder.Ascending],
       ['rank', SortingOrder.Ascending]
     ],