@api-client/core 0.13.6 → 0.14.1

package/tests/unit/modeling/domain_file.spec.ts

@@ -1,42 +1,28 @@
 import { test } from '@japa/runner'
 import { DomainFile, IDomainFile, ThingKind, DomainFileKind, DataDomain } from '../../../src/index.js'
 
-const organization = 'test-organization'
-
 test.group('DomainFile.fromDataDomain()', () => {
   test('sets the kind', ({ assert }) => {
     const p1 = new DataDomain({ info: { name: 'p1' } })
-    const result = DomainFile.fromDataDomain(p1, organization)
+    const result = DomainFile.fromDataDomain(p1)
     assert.equal(result.kind, DomainFileKind)
   })
 
-  test('sets the organization', ({ assert }) => {
-    const p1 = new DataDomain({ info: { name: 'p1' } })
-    const result = DomainFile.fromDataDomain(p1, organization)
-    assert.equal(result.organization, organization)
-  })
-
   test('sets the name', ({ assert }) => {
     const p1 = new DataDomain({ info: { name: 'p1' } })
-    const result = DomainFile.fromDataDomain(p1, organization)
+    const result = DomainFile.fromDataDomain(p1)
     assert.equal(result.info.name, 'p1')
   })
 
   test('sets the key', ({ assert }) => {
     const p1 = new DataDomain({ info: { name: 'p1' } })
-    const result = DomainFile.fromDataDomain(p1, organization)
+    const result = DomainFile.fromDataDomain(p1)
     assert.equal(result.key, p1.key)
   })
 
-  test('sets the configured owner', ({ assert }) => {
-    const p1 = new DataDomain({ info: { name: 'p1' } })
-    const result = DomainFile.fromDataDomain(p1, organization, 'other')
-    assert.equal(result.owner, 'other')
-  })
-
   test('respects schema instead of instance', ({ assert }) => {
     const p1 = new DataDomain({ info: { name: 'p1' } })
-    const result = DomainFile.fromDataDomain(p1.toJSON(), organization)
+    const result = DomainFile.fromDataDomain(p1.toJSON())
     assert.equal(result.info.name, 'p1')
   })
 })
@@ -45,7 +31,6 @@ test.group('constructor()', () => {
   test('creates a default data file', ({ assert }) => {
     const result = new DomainFile()
     assert.equal(result.kind, DomainFileKind)
-    assert.isUndefined(result.owner)
     assert.typeOf(result.key, 'string')
     assert.typeOf(result.lastModified, 'object')
   })
@@ -53,13 +38,11 @@ test.group('constructor()', () => {
   test('creates a data file from the schema values', ({ assert }) => {
     const schema: IDomainFile = {
       kind: DomainFileKind,
-      organization,
       info: {
         kind: ThingKind,
         name: 'hello',
         description: 'a desc',
       },
-      owner: 'me',
       key: '123',
       parents: ['p1'],
       permissionIds: ['pr1'],
@@ -81,9 +64,7 @@ test.group('constructor()', () => {
     }
     const result = new DomainFile(schema)
     assert.equal(result.kind, DomainFileKind)
-    assert.equal(result.organization, organization)
     assert.equal(result.info.name, 'hello')
-    assert.equal(result.owner, 'me')
     assert.equal(result.key, '123')
     assert.deepEqual(result.parents, ['p1'])
     assert.deepEqual(result.permissionIds, ['pr1'])
@@ -95,13 +76,11 @@ test.group('constructor()', () => {
   test('creates a data file from the JSON schema string', ({ assert }) => {
     const schema: IDomainFile = {
       kind: DomainFileKind,
-      organization,
       info: {
         kind: ThingKind,
         name: 'hello',
         description: 'a desc',
       },
-      owner: 'me',
       key: '123',
       parents: ['p1'],
       permissionIds: ['pr1'],
@@ -122,9 +101,7 @@ test.group('constructor()', () => {
     }
     const result = new DomainFile(JSON.stringify(schema))
     assert.equal(result.kind, DomainFileKind)
-    assert.equal(result.organization, organization)
     assert.equal(result.info.name, 'hello')
-    assert.equal(result.owner, 'me')
     assert.equal(result.key, '123')
     assert.deepEqual(result.lastModified, schema.lastModified)
   })

package/tests/unit/modeling/{domain.property.spec.ts → domain_property.spec.ts}

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
 import { DataDomain, DomainPropertyKind, DomainProperty, Thing, DataFormat } from '../../../src/index.js'
+import { SemanticType } from '../../../src/modeling/Semantics.js'
 
 test.group('DomainProperty.createSchema()', () => {
   test('creates a schema with default values', ({ assert }) => {
@@ -17,7 +18,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isUndefined(schema.writeOnly)
     assert.isUndefined(schema.deprecated)
     assert.isUndefined(schema.tags)
-    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.semantics)
     assert.isUndefined(schema.schema)
     assert.deepEqual(schema.bindings, [])
   })
@@ -34,7 +35,7 @@ test.group('DomainProperty.createSchema()', () => {
       writeOnly: true,
       deprecated: true,
       tags: ['tag1', 'tag2'],
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.CreatedTimestamp }],
       type: 'number',
       schema: { minimum: 0 },
       bindings: [{ type: 'web', schema: { format: 'float' } }],
@@ -51,7 +52,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isTrue(schema.writeOnly)
     assert.isTrue(schema.deprecated)
     assert.deepEqual(schema.tags, ['tag1', 'tag2'])
-    assert.deepEqual(schema.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(schema.semantics, [{ id: SemanticType.CreatedTimestamp }])
     assert.deepEqual(schema.schema, { minimum: 0 })
     assert.deepEqual(schema.bindings, [{ type: 'web', schema: { format: 'float' } }])
   })
@@ -87,7 +88,7 @@ test.group('DomainProperty.createSchema()', () => {
       writeOnly: undefined,
       deprecated: undefined,
       tags: undefined,
-      taxonomy: undefined,
+      semantics: undefined,
       schema: undefined,
       bindings: undefined,
     })
@@ -104,7 +105,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isUndefined(schema.writeOnly)
     assert.isUndefined(schema.deprecated)
     assert.isUndefined(schema.tags)
-    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.semantics)
     assert.isUndefined(schema.schema)
     assert.deepEqual(schema.bindings, [])
   })
@@ -128,7 +129,7 @@ test.group('DomainProperty.createSchema()', () => {
       // @ts-expect-error Testing null values
       tags: null,
       // @ts-expect-error Testing null values
-      taxonomy: null,
+      semantics: null,
       // @ts-expect-error Testing null values
       schema: null,
       // @ts-expect-error Testing null values
@@ -142,7 +143,7 @@ test.group('DomainProperty.createSchema()', () => {
     assert.isUndefined(schema.writeOnly)
     assert.isUndefined(schema.deprecated)
     assert.isUndefined(schema.tags)
-    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.semantics)
     assert.isUndefined(schema.schema)
     assert.deepEqual(schema.bindings, [])
   })
@@ -150,11 +151,11 @@ test.group('DomainProperty.createSchema()', () => {
   test('creates a schema with all properties empty array', ({ assert }) => {
     const schema = DomainProperty.createSchema({
       tags: [],
-      taxonomy: [],
+      semantics: [],
       bindings: [],
     })
     assert.deepEqual(schema.tags, [])
-    assert.deepEqual(schema.taxonomy, [])
+    assert.deepEqual(schema.semantics, [])
     assert.deepEqual(schema.bindings, [])
   })
 
@@ -180,11 +181,11 @@ test.group('DomainProperty.createSchema()', () => {
   test('creates a schema with all array properties set to empty arrays', ({ assert }) => {
     const schema = DomainProperty.createSchema({
       tags: [],
-      taxonomy: [],
+      semantics: [],
       bindings: [],
     })
     assert.deepEqual(schema.tags, [])
-    assert.deepEqual(schema.taxonomy, [])
+    assert.deepEqual(schema.semantics, [])
     assert.deepEqual(schema.bindings, [])
   })
 
@@ -202,12 +203,12 @@ test.group('DomainProperty.createSchema()', () => {
       // @ts-expect-error Testing null values
       tags: null,
       // @ts-expect-error Testing null values
-      taxonomy: null,
+      semantics: null,
       // @ts-expect-error Testing null values
       bindings: null,
     })
     assert.isUndefined(schema.tags)
-    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.semantics)
     assert.deepEqual(schema.bindings, [])
   })
 
@@ -242,7 +243,7 @@ test.group('DomainProperty.constructor()', () => {
     assert.isUndefined(property.writeOnly)
     assert.isUndefined(property.deprecated)
     assert.deepEqual(property.tags, [])
-    assert.deepEqual(property.taxonomy, [])
+    assert.deepEqual(property.semantics, [])
     assert.isUndefined(property.schema)
     assert.deepEqual(property.bindings, [])
     assert.equal(property['parent'], parent)
@@ -263,7 +264,7 @@ test.group('DomainProperty.constructor()', () => {
       writeOnly: true,
       deprecated: true,
       tags: ['tag1', 'tag2'],
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.CreatedTimestamp }],
       type: 'number',
       schema: { minimum: 0 },
       bindings: [{ type: 'web', schema: { format: 'float' } }],
@@ -281,7 +282,7 @@ test.group('DomainProperty.constructor()', () => {
     assert.isTrue(property.writeOnly)
     assert.isTrue(property.deprecated)
     assert.deepEqual(property.tags, ['tag1', 'tag2'])
-    assert.deepEqual(property.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(property.semantics, [{ id: SemanticType.CreatedTimestamp }])
     assert.deepEqual(property.schema, { minimum: 0 })
     assert.deepEqual(property.bindings, [{ type: 'web', schema: { format: 'float' } }])
     assert.equal(property['parent'], parent)
@@ -404,7 +405,7 @@ test.group('DomainProperty.toJSON()', () => {
     assert.isUndefined(json.writeOnly)
     assert.isUndefined(json.deprecated)
     assert.isUndefined(json.tags)
-    assert.isUndefined(json.taxonomy)
+    assert.isUndefined(json.semantics)
     assert.isUndefined(json.schema)
     assert.isUndefined(json.bindings)
   })
@@ -423,7 +424,7 @@ test.group('DomainProperty.toJSON()', () => {
       writeOnly: true,
       deprecated: true,
       tags: ['tag1', 'tag2'],
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.CreatedTimestamp }],
       type: 'number',
       schema: { minimum: 0 },
       bindings: [{ type: 'web', schema: { format: 'float' } }],
@@ -442,7 +443,7 @@ test.group('DomainProperty.toJSON()', () => {
     assert.isTrue(json.writeOnly)
     assert.isTrue(json.deprecated)
     assert.deepEqual(json.tags, ['tag1', 'tag2'])
-    assert.deepEqual(json.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(json.semantics, [{ id: SemanticType.CreatedTimestamp }])
     assert.deepEqual(json.schema, { minimum: 0 })
     assert.deepEqual(json.bindings, [{ type: 'web', schema: { format: 'float' } }])
   })
@@ -452,13 +453,13 @@ test.group('DomainProperty.toJSON()', () => {
     const parent = 'test-parent'
     const property = new DomainProperty(root, parent, {
       tags: [],
-      taxonomy: [],
+      semantics: [],
       bindings: [],
     })
     const json = property.toJSON()
 
     assert.isUndefined(json.tags)
-    assert.isUndefined(json.taxonomy)
+    assert.isUndefined(json.semantics)
     assert.isUndefined(json.bindings)
   })
 
@@ -474,7 +475,7 @@ test.group('DomainProperty.toJSON()', () => {
       writeOnly: undefined,
       deprecated: undefined,
       tags: undefined,
-      taxonomy: undefined,
+      semantics: undefined,
       schema: undefined,
       bindings: undefined,
     })
@@ -488,7 +489,7 @@ test.group('DomainProperty.toJSON()', () => {
     assert.isUndefined(json.writeOnly)
     assert.isUndefined(json.deprecated)
     assert.isUndefined(json.tags)
-    assert.isUndefined(json.taxonomy)
+    assert.isUndefined(json.semantics)
     assert.isUndefined(json.schema)
     assert.isUndefined(json.bindings)
   })
@@ -820,3 +821,118 @@ test.group('DomainProperty.toApiShape()', () => {
     assert.isDefined(result)
   })
 })
+
+test.group('DomainProperty.addSemantic()', () => {
+  test('adds a new semantic to the property', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic = { id: SemanticType.CreatedTimestamp }
+    property.addSemantic(semantic)
+    assert.deepInclude(property.semantics, semantic)
+  })
+
+  test('updates an existing semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic1 = { id: SemanticType.CreatedTimestamp, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.CreatedTimestamp, config: { value: 'new' } }
+    property.addSemantic(semantic1)
+    property.addSemantic(semantic2)
+    assert.lengthOf(property.semantics, 1)
+    assert.deepInclude(property.semantics, semantic2)
+  })
+
+  test('throws an error if the semantic is not a property semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.User } // User is an Entity semantic
+    assert.throws(() => {
+      property.addSemantic(semantic)
+    }, `Invalid semantic type: ${SemanticType.User}. Expected a property semantic.`)
+  })
+
+  test('notifies change when adding a new semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic = { id: SemanticType.CreatedTimestamp }
+    property.addSemantic(semantic)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('notifies change when updating an existing semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic1 = { id: SemanticType.CreatedTimestamp, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.CreatedTimestamp, config: { value: 'new' } }
+    property.addSemantic(semantic1)
+    // Clear the event queue before the second add
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    property.addSemantic(semantic2)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainProperty.removeSemantic()', () => {
+  test('removes an existing semantic from the property', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic = { id: SemanticType.CreatedTimestamp }
+    property.addSemantic(semantic)
+    assert.deepInclude(property.semantics, semantic)
+    property.removeSemantic(SemanticType.CreatedTimestamp)
+    assert.notDeepInclude(property.semantics, semantic)
+    assert.lengthOf(property.semantics, 0)
+  })
+
+  test('does nothing if the semantic to remove does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic = { id: SemanticType.CreatedTimestamp }
+    property.addSemantic(semantic)
+    const initialSemantics = [...property.semantics]
+    property.removeSemantic('non-existent-semantic-id' as SemanticType)
+    assert.deepEqual(property.semantics, initialSemantics)
+  })
+
+  test('notifies change when a semantic is removed', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic = { id: SemanticType.CreatedTimestamp }
+    property.addSemantic(semantic)
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    property.removeSemantic(SemanticType.CreatedTimestamp)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('does not notify change if the semantic to remove does not exist', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    property.removeSemantic('non-existent-semantic-id' as SemanticType)
+    await assert.notDispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainProperty.hasSemantic()', () => {
+  test('returns true if the property has the specified semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent', { type: 'datetime' })
+    const semantic = { id: SemanticType.CreatedTimestamp }
+    property.addSemantic(semantic)
+    assert.isTrue(property.hasSemantic(SemanticType.CreatedTimestamp))
+  })
+
+  test('returns false if the property does not have the specified semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    assert.isFalse(property.hasSemantic(SemanticType.CreatedTimestamp))
+  })
+
+  test('returns false for an empty semantics array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'test-parent')
+    assert.isFalse(property.hasSemantic(SemanticType.CreatedTimestamp))
+  })
+})

package/tests/unit/models/Certificate/from_name.spec.ts

@@ -1,32 +1,20 @@
 import { test } from '@japa/runner'
 import { CertificateFile, CertificateFileKind } from '../../../../src/index.js'
 
-const organization = 'test-organization'
-
 test.group('CertificateFile.fromName()', () => {
   test('sets the kind', ({ assert }) => {
-    const result = CertificateFile.fromName('name', organization)
+    const result = CertificateFile.fromName('name')
     assert.equal(result.kind, CertificateFileKind)
   })
 
-  test('sets the organization', ({ assert }) => {
-    const result = CertificateFile.fromName('name', organization)
-    assert.equal(result.organization, organization)
-  })
-
   test('sets the name', ({ assert }) => {
-    const result = CertificateFile.fromName('name', organization)
+    const result = CertificateFile.fromName('name')
     assert.equal(result.info.name, 'name')
   })
 
   test('sets the key', ({ assert }) => {
-    const result = CertificateFile.fromName('name', organization)
+    const result = CertificateFile.fromName('name')
     assert.typeOf(result.key, 'string')
     assert.notEqual(result.key, '')
   })
-
-  test('sets the owner', ({ assert }) => {
-    const result = CertificateFile.fromName('name', organization, 'other')
-    assert.equal(result.owner, 'other')
-  })
 })

package/tests/unit/models/File/constructor.spec.ts

@@ -5,7 +5,6 @@ test.group('File.constructor()', () => {
   test('creates a default File', ({ assert }) => {
     const result = new File()
     assert.equal(result.kind, '')
-    assert.isUndefined(result.owner)
     assert.equal(result.key, '')
     assert.deepEqual(result.info.toJSON(), { kind: ThingKind, name: '' })
     assert.deepEqual(result.parents, [])

package/tests/unit/models/File/new.spec.ts

@@ -4,18 +4,15 @@ import { File, ThingKind, IFile } from '../../../../src/index.js'
 test.group('File.new()', (group) => {
   let file: File
   let base: IFile
-  const organization = 'test123'
   group.each.setup(async () => {
     file = new File()
     base = {
       kind: 'test-kind',
-      organization,
       info: {
         kind: ThingKind,
         name: 'hello',
         description: 'a desc',
       },
-      owner: 'me',
       key: '123',
       parents: ['p1'],
       permissionIds: ['pr1'],
@@ -45,11 +42,6 @@ test.group('File.new()', (group) => {
     assert.equal(file.key, '123')
   })
 
-  test('sets the organization', ({ assert }) => {
-    file.new({ ...base })
-    assert.equal(file.organization, organization)
-  })
-
   test('sets a new key when missing', ({ assert }) => {
     const iFile = { ...base }
     Reflect.deleteProperty(iFile, 'key')
@@ -99,11 +91,6 @@ test.group('File.new()', (group) => {
     assert.deepEqual(file.permissionIds, [])
   })
 
-  test('sets the owner', ({ assert }) => {
-    file.new({ ...base })
-    assert.equal(file.owner, 'me')
-  })
-
   test('sets the lastModified', ({ assert }) => {
     file.new({ ...base })
     assert.deepEqual(file.lastModified, base.lastModified)

package/tests/unit/models/File/shortcutTo.spec.ts

@@ -46,8 +46,7 @@ test.group('File.shortcutTo()', () => {
   })
 
   test('creates a shortcut from a name with fromName()', ({ assert }) => {
-    const organization = 'test-org'
-    const file = File.fromName('test-file', organization)
+    const file = File.fromName('test-file')
     const targetId = 'target-file-id'
     file.shortcutTo(targetId)
     assert.equal(file.shortcutTarget, targetId)

package/tests/unit/models/File/toJSON.spec.ts

@@ -4,19 +4,16 @@ import { File, ThingKind, IFile } from '../../../../src/index.js'
 test.group('File.toJSON()', (group) => {
   let file: File
   let base: IFile
-  const organization = 'test123'
 
   group.each.setup(() => {
     file = new File()
     base = {
       kind: 'test-kind',
-      organization,
       info: {
         kind: ThingKind,
         name: 'hello',
         description: 'a desc',
       },
-      owner: 'me',
       key: '123',
       parents: ['p1'],
       permissionIds: ['pr1'],
@@ -43,21 +40,11 @@ test.group('File.toJSON()', (group) => {
     assert.equal(result.key, base.key)
   })
 
-  test('sets the organization', ({ assert }) => {
-    const result = file.toJSON()
-    assert.equal(result.organization, organization)
-  })
-
   test('sets the kind', ({ assert }) => {
     const result = file.toJSON()
     assert.equal(result.kind, base.kind)
   })
 
-  test('sets the owner', ({ assert }) => {
-    const result = file.toJSON()
-    assert.equal(result.owner, base.owner)
-  })
-
   test('sets the info', ({ assert }) => {
     const result = file.toJSON()
     assert.deepEqual(result.info, base.info)

package/tests/unit/models/File/updateByMeMeta.spec.ts

@@ -2,10 +2,8 @@ import { test } from '@japa/runner'
 import { File, Folder } from '../../../../src/index.js'
 
 test.group('File.updateByMeMeta()', () => {
-  const organization = 'test123'
-
   test('sets deletedInfo.byMe for the same user', ({ assert }) => {
-    const schema = Folder.fromName('s1', organization).toJSON()
+    const schema = Folder.fromName('s1').toJSON()
     schema.deletedInfo = {
       byMe: false,
       time: 1,
@@ -17,7 +15,7 @@ test.group('File.updateByMeMeta()', () => {
   })
 
   test('sets deletedInfo.byMe for the different user', ({ assert }) => {
-    const schema = Folder.fromName('s1', organization).toJSON()
+    const schema = Folder.fromName('s1').toJSON()
     schema.deletedInfo = {
       byMe: false,
       time: 1,
@@ -29,7 +27,7 @@ test.group('File.updateByMeMeta()', () => {
   })
 
   test('sets lastModified.byMe for the same user', ({ assert }) => {
-    const schema = Folder.fromName('s1', organization).toJSON()
+    const schema = Folder.fromName('s1').toJSON()
     schema.lastModified = {
       byMe: false,
       time: 1,
@@ -41,7 +39,7 @@ test.group('File.updateByMeMeta()', () => {
   })
 
   test('sets lastModified.byMe for the different user', ({ assert }) => {
-    const schema = Folder.fromName('s1', organization).toJSON()
+    const schema = Folder.fromName('s1').toJSON()
     schema.lastModified = {
       byMe: false,
       time: 1,

package/tests/unit/models/Folder/create.spec.ts

@@ -1,35 +1,22 @@
 import { test } from '@japa/runner'
 import { Folder, FolderKind, IFolder, ThingKind } from '../../../../src/index.js'
 
-const organization = 'test-organization'
-
 test.group('Folder.fromName()', () => {
   test('sets the kind', ({ assert }) => {
-    const result = Folder.fromName('name', organization)
+    const result = Folder.fromName('name')
     assert.equal(result.kind, FolderKind)
   })
 
-  test('sets the organization', ({ assert }) => {
-    const result = Folder.fromName('name', organization)
-    assert.equal(result.organization, organization)
-  })
-
   test('sets the name', ({ assert }) => {
-    const result = Folder.fromName('name', organization)
+    const result = Folder.fromName('name')
     assert.equal(result.info.name, 'name')
   })
-
-  test('sets the passed owner', ({ assert }) => {
-    const result = Folder.fromName('name', organization, 'me')
-    assert.equal(result.owner, 'me')
-  })
 })
 
 test.group('Folder.constructor()', () => {
   test('creates a default Folder', ({ assert }) => {
     const result = new Folder()
     assert.equal(result.kind, FolderKind)
-    assert.isUndefined(result.owner)
     assert.typeOf(result.key, 'string')
     assert.typeOf(result.lastModified, 'object')
   })
@@ -37,13 +24,11 @@ test.group('Folder.constructor()', () => {
   test('creates a Folder from the schema values', ({ assert }) => {
     const schema: IFolder = {
       kind: FolderKind,
-      organization,
       info: {
         kind: ThingKind,
         name: 'hello',
         description: 'a desc',
       },
-      owner: 'me',
       key: '123',
       parents: ['p1'],
       permissionIds: ['pr1'],
@@ -65,9 +50,7 @@ test.group('Folder.constructor()', () => {
     }
     const result = new Folder(schema)
     assert.equal(result.kind, FolderKind)
-    assert.equal(result.organization, organization)
     assert.equal(result.info.name, 'hello')
-    assert.equal(result.owner, 'me')
     assert.equal(result.key, '123')
     assert.deepEqual(result.parents, ['p1'])
     assert.deepEqual(result.permissionIds, ['pr1'])
@@ -79,13 +62,11 @@ test.group('Folder.constructor()', () => {
   test('creates a Folder from the JSON schema string', ({ assert }) => {
     const schema: IFolder = {
       kind: FolderKind,
-      organization,
       info: {
         kind: ThingKind,
         name: 'hello',
         description: 'a desc',
       },
-      owner: 'me',
       key: '123',
       parents: ['p1'],
       permissionIds: ['pr1'],
@@ -106,9 +87,7 @@ test.group('Folder.constructor()', () => {
     }
     const result = new Folder(JSON.stringify(schema))
     assert.equal(result.kind, FolderKind)
-    assert.equal(result.organization, organization)
     assert.equal(result.info.name, 'hello')
-    assert.equal(result.owner, 'me')
     assert.equal(result.key, '123')
     assert.deepEqual(result.lastModified, schema.lastModified)
   })