@api-client/core 0.13.6 → 0.14.1

package/src/modeling/DomainImpactAnalysis.ts

@@ -436,7 +436,7 @@ export class DomainImpactAnalysis {
         this.deleteNamespaceAnalysis(key, rootKey)
         break
       case DomainModelKind:
-        this.deleteDataModelAnalysis(key, rootKey)
+        this.deleteModelAnalysis(key, rootKey)
         break
       case DomainEntityKind:
         this.deleteEntityAnalysis(key, rootKey)
@@ -469,11 +469,11 @@ export class DomainImpactAnalysis {
       this.deleteNamespaceAnalysis(child.key, rootKey)
     }
     for (const child of ns.listModels()) {
-      this.deleteDataModelAnalysis(child.key, rootKey)
+      this.deleteModelAnalysis(child.key, rootKey)
     }
   }
 
-  protected deleteDataModelAnalysis(key: string, rootKey: string): void {
+  protected deleteModelAnalysis(key: string, rootKey: string): void {
     const model = this.root.findModel(key)
     if (!model) {
       return

package/src/modeling/DomainModel.ts

@@ -64,10 +64,10 @@ export interface DomainModelSchema extends DomainElementSchema {
  *
  * ```typescript
  * const dataDomain = new DataDomain();
- * const dataNamespace = dataDomain.addNamespace({
+ * const ns = dataDomain.addNamespace({
  *   key: 'myNamespace',
  * });
- * const userModel = dataNamespace.addModel({
+ * const userModel = ns.addModel({
  *   key: 'userModel',
  *   info: { name: 'User Model' },
  * });

package/src/modeling/DomainProperty.ts

@@ -16,12 +16,13 @@ import {
   type NumberFormat,
   NumberFormats,
 } from './DataFormat.js'
+import { ShapeGenerator } from './amf/ShapeGenerator.js'
 import type { PropertyBinding, PropertyBindings, PropertyWebBindings } from './Bindings.js'
 import type { ModelValidationOptions } from '../models/types.js'
 import type { DomainEntity } from './DomainEntity.js'
 import type { IApiPropertyShape } from '../amf/definitions/Shapes.js'
-import { ShapeGenerator } from './amf/ShapeGenerator.js'
-import { PropertySchema } from './types.js'
+import type { PropertySchema } from './types.js'
+import { DataSemantics, isPropertySemantic, type SemanticType, type AppliedDataSemantic } from './Semantics.js'
 
 export interface DomainPropertySchema extends DomainElementSchema {
   kind: typeof DomainPropertyKind
@@ -62,11 +63,11 @@ export interface DomainPropertySchema extends DomainElementSchema {
    */
   tags?: string[]
   /**
-   * For future use.
-   *
-   * The keys of the taxonomy items associated with the property.
+   * The semantics applied to this property.
+   * This is a list of applied semantics that can be used to
+   * describe the property in more detail.
    */
-  taxonomy?: string[]
+  semantics?: AppliedDataSemantic[]
   /**
    * The data type for this property.
    * Note, not all schemas support the same type. For example, defining `sint32`
@@ -106,21 +107,21 @@ export interface DomainPropertySchema extends DomainElementSchema {
  * -   **Bindings:** Allows defining how the property is
  *     represented in different formats (e.g., web APIs,
  *     protocol buffers).
- * -   **Metadata:** Supports metadata such as tags, taxonomy,
+ * -   **Metadata:** Supports metadata such as tags, semantics,
  *     read-only/write-only status, and deprecation.
  * -   **Schema:** Allows defining a general schema for the
  *     property, which is propagated to all bindings.
  *
  * **Usage:**
  *
- * Use the `DataEntity.addProperty` method to add a new property to an
+ * Use the `DomainEntity.addProperty` method to add a new property to an
  * entity. The property can be created using the constructor, but it
  * won't be added to the graph until you call the `addProperty` method.
  *
  * **Example:**
  *
  * ```typescript
- * const entity = dataModel.addEntity({ key: 'user' });
+ * const entity = domainModel.addEntity({ key: 'user' });
  * const property = entity.addProperty({
  *   key: 'name',
  *   type: 'string',
@@ -185,11 +186,9 @@ export class DomainProperty extends DomainElement {
   @observed({ deep: true }) accessor tags: string[] = []
 
   /**
-   * Reserved for future use.
-   *
-   * The keys of the taxonomy items associated with the property.
+   * Semantics applied to this property.
    */
-  @observed({ deep: true }) accessor taxonomy: string[] = []
+  @observed({ deep: true }) accessor semantics: AppliedDataSemantic[] = []
 
   /**
    * The data type for this property.
@@ -232,7 +231,7 @@ export class DomainProperty extends DomainElement {
       readOnly,
       writeOnly,
       tags,
-      taxonomy,
+      semantics,
       deprecated,
       schema,
       bindings,
@@ -273,8 +272,8 @@ export class DomainProperty extends DomainElement {
     if (Array.isArray(tags)) {
       result.tags = [...tags]
     }
-    if (Array.isArray(taxonomy)) {
-      result.taxonomy = [...taxonomy]
+    if (Array.isArray(semantics)) {
+      result.semantics = [...semantics]
     }
     if (schema) {
       result.schema = structuredClone(schema)
@@ -353,10 +352,10 @@ export class DomainProperty extends DomainElement {
     } else {
       this.tags = []
     }
-    if (Array.isArray(init.taxonomy)) {
-      this.taxonomy = [...init.taxonomy]
+    if (Array.isArray(init.semantics)) {
+      this.semantics = [...init.semantics]
     } else {
-      this.taxonomy = []
+      this.semantics = []
     }
     if (init.schema) {
       this.schema = structuredClone(init.schema)
@@ -419,8 +418,8 @@ export class DomainProperty extends DomainElement {
     if (Array.isArray(this.tags) && this.tags.length) {
       result.tags = [...this.tags]
     }
-    if (Array.isArray(this.taxonomy) && this.taxonomy.length) {
-      result.taxonomy = [...this.taxonomy]
+    if (Array.isArray(this.semantics) && this.semantics.length) {
+      result.semantics = toRaw(this, this.semantics)?.map((i) => structuredClone(i))
     }
     if (this.schema) {
       result.schema = structuredClone(toRaw(this, this.schema))
@@ -545,4 +544,44 @@ export class DomainProperty extends DomainElement {
     const serializer = new ShapeGenerator()
     return serializer.property(this)
   }
+
+  /**
+   * Adds or updates a semantic to the property.
+   * @param semantic The semantic to add to the property.
+   * @throws Error if the semantic is not an property semantic.
+   */
+  addSemantic(semantic: AppliedDataSemantic): void {
+    const sem = DataSemantics[semantic.id]
+    if (!isPropertySemantic(sem)) {
+      throw new Error(`Invalid semantic type: ${semantic.id}. Expected a property semantic.`)
+    }
+    const index = this.semantics.findIndex((s) => s.id === semantic.id)
+    if (index >= 0) {
+      this.semantics[index] = semantic
+    } else {
+      this.semantics.push(semantic)
+    }
+    this.domain.notifyChange()
+  }
+
+  /**
+   * Removes a semantic from the property.
+   * @param semanticId The ID of the semantic to remove.
+   */
+  removeSemantic(semanticId: SemanticType): void {
+    const index = this.semantics.findIndex((s) => s.id === semanticId)
+    if (index >= 0) {
+      this.semantics.splice(index, 1)
+      this.domain.notifyChange()
+    }
+  }
+
+  /**
+   * Checks if the property has a specific semantic.
+   * @param semanticId The ID of the semantic to check.
+   * @returns True if the semantic is present, false otherwise.
+   */
+  hasSemantic(semanticId: SemanticType): boolean {
+    return this.semantics.some((s) => s.id === semanticId)
+  }
 }

package/src/modeling/Semantics.ts

@@ -0,0 +1,178 @@
+import type { DomainPropertyType } from './DataFormat.js'
+
+/**
+ * Defines the names for all available data semantics.
+ * Using a string enum makes it easy to add or remove semantics in a single place.
+ */
+export enum SemanticType {
+  // Entity-Level Semantics
+  /**
+   * Designates a Data Entity that represents users of the system.
+   */
+  User = 'https://apinow.app/semantics/entities/#User',
+
+  // Property-Level Semantics
+  CreatedTimestamp = 'https://apinow.app/semantics/properties/#CreatedTimestamp',
+  UpdatedTimestamp = 'https://apinow.app/semantics/properties/#UpdatedTimestamp',
+  DeletedTimestamp = 'https://apinow.app/semantics/properties/#DeletedTimestamp',
+  DeletedFlag = 'https://apinow.app/semantics/properties/#DeletedFlag',
+  PublicUniqueName = 'https://apinow.app/semantics/properties/#PublicUniqueName',
+  // Association-Level Semantics
+  ResourceOwnerIdentifier = 'https://apinow.app/semantics/associations/#ResourceOwnerIdentifier',
+}
+
+/**
+ * Defines the scope at which a semantic can be applied.
+ */
+export enum SemanticScope {
+  Entity = 'Entity',
+  Property = 'Property',
+  Association = 'Association',
+}
+
+/**
+ * A base interface for all Data Semantics, containing common properties.
+ * A semantic is an annotation applied to a Data Entity, Property, or Association
+ * to provide additional context or constraints.
+ * This interface is extended by more specific semantic types.
+ */
+interface BaseDataSemantic {
+  /**
+   * A unique identifier for the semantic definition.
+   */
+  id: SemanticType
+  /**
+   * A human-readable name for the semantic.
+   */
+  displayName: string
+  /**
+   * A description of the semantic's purpose and impact.
+   */
+  description: string
+  /**
+   * Specifies whether the semantic applies to an Entity, Property, or Association.
+   */
+  scope: SemanticScope
+}
+
+/**
+ * Represents a semantic that can be applied to an entire Data Entity.
+ */
+export interface EntitySemantic extends BaseDataSemantic {
+  scope: SemanticScope.Entity
+}
+
+/**
+ * Represents a semantic that can be applied to a single property.
+ */
+export interface PropertySemantic extends BaseDataSemantic {
+  scope: SemanticScope.Property
+  /**
+   * Optional array of data types this semantic can be applied to.
+   * Enforces constraints, e.g., DeletedTimestamp on a DateTime property.
+   */
+  applicableDataTypes?: DomainPropertyType[]
+}
+
+/**
+ * Represents a semantic that can be applied to an association between entities.
+ */
+export interface AssociationSemantic extends BaseDataSemantic {
+  scope: SemanticScope.Association
+}
+
+/**
+ * A type guard to check if a semantic is an EntitySemantic.
+ */
+export const isEntitySemantic = (semantic: DataSemantic): semantic is EntitySemantic =>
+  semantic.scope === SemanticScope.Entity
+
+/**
+ * A type guard to check if a semantic is a PropertySemantic.
+ */
+export const isPropertySemantic = (semantic: DataSemantic): semantic is PropertySemantic =>
+  semantic.scope === SemanticScope.Property
+
+/**
+ * A type guard to check if a semantic is a AssociationSemantic.
+ */
+export const isAssociationSemantic = (semantic: DataSemantic): semantic is AssociationSemantic =>
+  semantic.scope === SemanticScope.Association
+
+/**
+ * Union type for any kind of data semantic
+ */
+export type DataSemantic = EntitySemantic | PropertySemantic | AssociationSemantic
+
+/**
+ * A map to store the definitions of all available data semantics.
+ * This acts as a central registry for the application.
+ */
+export const DataSemantics: Record<SemanticType, DataSemantic> = {
+  // Entity-Level Definitions
+  [SemanticType.User]: {
+    id: SemanticType.User,
+    displayName: 'User Entity',
+    scope: SemanticScope.Entity,
+    description: 'Designates an entity that represents system users, crucial for authentication and authorization.',
+  },
+
+  // Property-Level Definitions
+  [SemanticType.CreatedTimestamp]: {
+    id: SemanticType.CreatedTimestamp,
+    displayName: 'Creation Timestamp',
+    scope: SemanticScope.Property,
+    description: "Marks a field as the one that contains the object's creation timestamp.",
+    applicableDataTypes: ['datetime'],
+  },
+  [SemanticType.UpdatedTimestamp]: {
+    id: SemanticType.UpdatedTimestamp,
+    displayName: 'Update Timestamp',
+    scope: SemanticScope.Property,
+    description: "Marks a field as the field that contains object's last modification timestamp.",
+    applicableDataTypes: ['datetime'],
+  },
+  [SemanticType.DeletedTimestamp]: {
+    id: SemanticType.DeletedTimestamp,
+    displayName: 'Soft Delete Timestamp',
+    scope: SemanticScope.Property,
+    description: "Marks a field as the field that contains object's deletion timestamp.",
+    applicableDataTypes: ['datetime'],
+  },
+  [SemanticType.DeletedFlag]: {
+    id: SemanticType.DeletedFlag,
+    displayName: 'Soft Delete Flag',
+    scope: SemanticScope.Property,
+    description: 'A boolean property that marks the object as deleted without physically removing it.',
+    applicableDataTypes: ['boolean'],
+  },
+  [SemanticType.ResourceOwnerIdentifier]: {
+    id: SemanticType.ResourceOwnerIdentifier,
+    displayName: 'Resource Owner Identifier',
+    scope: SemanticScope.Association,
+    description: 'Links a resource to a "User" entity instance, indicating ownership for access control.',
+  },
+  [SemanticType.PublicUniqueName]: {
+    id: SemanticType.PublicUniqueName,
+    displayName: 'Public Unique Name (Slug)',
+    scope: SemanticScope.Property,
+    description: 'A user-friendly, unique public identifier for a resource, often used in URLs.',
+    applicableDataTypes: ['string'],
+  },
+}
+
+/**
+ * Represents the application of a data semantic to a specific
+ * entity or property within a user's data model.
+ */
+export interface AppliedDataSemantic {
+  /**
+   * The unique identifier of the semantic being applied.
+   */
+  id: SemanticType
+
+  /**
+   * Optional configuration or values specific to this application.
+   */
+  config?: Record<string, unknown>
+}

package/src/modeling/graph.md

@@ -4,20 +4,20 @@
 
 ```plain
 DataDomain (Root container)
-  ├── DataNamespace (logical grouping)
-  │   └── DataModel
-  │       └── DataEntity
+  ├── DomainNamespace (logical grouping)
+  │   └── DomainModel
+  │       └── DomainEntity
   │           ├── Property (name, type, ...)
   │           ├── Association (name, cardinality, target Entity)
-  │           └── ParentEntity (reference to another DataEntity)
-  ├── DataModel
-  │   └── DataEntity
+  │           └── ParentEntity (reference to another DomainEntity)
+  ├── DomainModel
+  │   └── DomainEntity
   │       ├── Property
   │       ├── Association
   │       └── ParentEntity
-  └── ForeignDataNamespace (immutable, imported from another DataDomain)
-      └── DataModel
-          └── DataEntity
+  └── ForeignDomainNamespace (immutable, imported from another DataDomain)
+      └── DomainModel
+          └── DomainEntity
               ├── Property
               ├── Association
               └── ParentEntity
@@ -31,11 +31,11 @@ Here's a breakdown of how each element is represented in the graph:
 
 **Nodes:**
 
-* **Namespace:** Represents a `DataNamespace`. It's a container for models and other namespaces.
-* **Model:** Represents a `DataModel`. It's a container for entities.
-* **Entity:** Represents a `DataEntity`. It's the fundamental building block, defining a specific type of data.
-* **Property:** Represents a `DataProperty`. It's an attribute of an entity.
-* **Association:** Represents a `DataAssociation`. It defines a relationship between entities.
+* **Namespace:** Represents a `DomainNamespace`. It's a container for models and other namespaces.
+* **Model:** Represents a `DomainModel`. It's a container for entities.
+* **Entity:** Represents a `DomainEntity`. It's the fundamental building block, defining a specific type of data.
+* **Property:** Represents a `DomainProperty`. It's an attribute of an entity.
+* **Association:** Represents a `DomainAssociation`. It defines a relationship between entities.
 
 **Edges:**
 

package/src/modeling/readme.md

@@ -4,53 +4,53 @@
 
 At the heart of this data modeling system are the following fundamental concepts.
 
-### DataNamespace
+### DomainNamespace
 
 This is the top-level container, representing a logical grouping of data. Think of it as a "domain" or a "schema" in a database. It can contain:
 
-- `DataModels`: Logical groupings of entities.
+- `DomainModels`: Logical groupings of entities.
 - `DataEntities`: The basic building blocks, representing individual data structures.
 - `DataProperties`: Attributes of entities (e.g., name, age, address).
-- `DataAssociations`: Relationships between entities (e.g., a user has an address).
+- `DomainAssociations`: Relationships between entities (e.g., a user has an address).
 - `Sub-namespaces`: Namespaces can be nested within each other, creating a hierarchical structure.
 - `Foreign Namespaces`: References to external namespaces, enabling the use of entities defined elsewhere.
 - `Tags`: Common tags for the entire namespace.
 
-### DataModel
+### DomainModel
 
-A logical grouping of `DataEntity` instances. It represents a specific data structure, like a "Product" or "User" model. A `DataModel` can contain multiple `DataEntity` instances.
+A logical grouping of `DomainEntity` instances. It represents a specific data structure, like a "Product" or "User" model. A `DomainModel` can contain multiple `DomainEntity` instances.
 
-### DataEntity
+### DomainEntity
 
 The fundamental building block of the data model. It represents a specific type of data, like a "User," "Product," or "Address."
 
-- `Properties`: DataProperty instances that describe the attributes of the entity.
-- `Associations`: DataAssociation instances that define relationships to other entities.
+- `Properties`: DomainProperty instances that describe the attributes of the entity.
+- `Associations`: DomainAssociation instances that define relationships to other entities.
 - `Parents`: An entity can inherit from other entities, creating a hierarchy.
 - `Fields`: Ordered list of properties and associations.
 - `Tags`: Optional tags for the UI.
-- `Taxonomy`: Reserved for future use.
+- `Semantics`: A system of predefined, meaningful labels or classifications that can be applied to Data Entities or their individual properties.
 - `Deprecated`: Whether the entity is deprecated.
 - `Schema`: The schema allowing to translate the model into a specific format (like JSON, RAML, XML, etc.)
 
-### DataProperty
+### DomainProperty
 
-Represents an attribute of a `DataEntity`. It has a name, a data type (e.g., string, number, boolean), and optional constraints (e.g., required, multiple, min/max values).
+Represents an attribute of a `DomainEntity`. It has a name, a data type (e.g., string, number, boolean), and optional constraints (e.g., required, multiple, min/max values).
 
 - `Type`: The data type of the property.
 - `Schema`: The general schema definition of this property.
 - `Bindings`: The list of bindings for this property.
 - `Tags`: Optional tags for the UI.
-- `Taxonomy`: Reserved for future use.
+- `Semantics`: A system of predefined, meaningful labels or classifications that can be applied to Data Entities or their individual properties.
 - `Deprecated`: Whether the property is deprecated.
 - `Primary`: Whether this property describes a primary key of the entity.
 - `Index`: Whether this property describes an indexed property of the entity.
 - `ReadOnly`: Whether the property is read only in the schema.
 - `WriteOnly`: Whether the property is write only in the schema.
 
-### DataAssociation
+### DomainAssociation
 
-Defines a relationship between `DataEntity` instances. It specifies the target entities and the nature of the relationship (e.g., one-to-one, one-to-many).
+Defines a relationship between `DomainEntity` instances. It specifies the target entities and the nature of the relationship (e.g., one-to-one, one-to-many).
 
 - `Targets`: The list of target entities.
 - `Multiple`: Whether the association allows multiple target entities.
@@ -67,24 +67,24 @@ Defines a translation from a data model to a specific format (like JSON, RAML, X
 
 Here's how these components work together to structure a data domain:
 
-1. **Root Namespace**: You start with a `DataNamespace`, which acts as the root of your data domain. This namespace is the top-level container for all other elements.
+1. **Root Namespace**: You start with a `DomainNamespace`, which acts as the root of your data domain. This namespace is the top-level container for all other elements.
 
 1. **Sub-namespaces (Optional)**: You can create sub-namespaces within the root namespace to further organize your data. This is useful for large domains with many entities and relationships.
 
-1. **Data Models**: Within a namespace (or sub-namespace), you define `DataModel` instances. Each `DataModel` represents a specific area of your domain. For example, you might have a "User Management" `DataModel`, a "Product Catalog" `DataModel`, and an "Order Processing" `DataModel`.
+1. **Data Models**: Within a namespace (or sub-namespace), you define `DomainModel` instances. Each `DomainModel` represents a specific area of your domain. For example, you might have a "User Management" `DomainModel`, a "Product Catalog" `DomainModel`, and an "Order Processing" `DomainModel`.
 
-1. **Data Entities**: Inside each `DataModel`, you define `DataEntity` instances. These are the core data structures. For example, in the "User Management" `DataModel`, you might have `DataEntity` instances for "User," "Role," and "Permission."
+1. **Data Entities**: Inside each `DomainModel`, you define `DomainEntity` instances. These are the core data structures. For example, in the "User Management" `DomainModel`, you might have `DomainEntity` instances for "User," "Role," and "Permission."
 
-1. **Data Properties**: Each `DataEntity` has `DataProperty` instances that describe its attributes. For example, the "User" `DataEntity` might have `DataProperty` instances for "firstName" (string), "lastName" (string), "email" (string), "age" (number), etc.
+1. **Data Properties**: Each `DomainEntity` has `DomainProperty` instances that describe its attributes. For example, the "User" `DomainEntity` might have `DomainProperty` instances for "firstName" (string), "lastName" (string), "email" (string), "age" (number), etc.
 
-1. **Data Associations**: You use `DataAssociation` instances to define relationships between `DataEntity` instances. For example:
+1. **Data Associations**: You use `DomainAssociation` instances to define relationships between `DomainEntity` instances. For example:
 
    - A "User" has an "Address" (one-to-one).
    - A "User" has multiple "Roles" (one-to-many).
    - A "Product" belongs to a "Category" (many-to-one).
    - An "Order" contains multiple "Order Items" (one-to-many).
 
-1. **Inheritance**: `DataEntity` instances can inherit from other `DataEntity` instances using the parents property. This allows you to create a hierarchy of entities and reuse common properties and associations.
+1. **Inheritance**: `DomainEntity` instances can inherit from other `DomainEntity` instances using the parents property. This allows you to create a hierarchy of entities and reuse common properties and associations.
 
 1. **Foreign Namespaces**: You can reference entities from other namespaces using the foreign property of the root namespace. This allows you to reuse data structures defined elsewhere.
 
@@ -109,18 +109,18 @@ Let's imagine a simple e-commerce domain:
         - **Data Association**: `address` (references `Address` entity)
       - **Data Entity**: `Address`
         - **Data Properties**: `street` (string), `city` (string), `zipCode` (string), `country` (string)
-  - **Foreign Namespace**: `Taxonomy` (defined elsewhere)
-    - **Data Model**: `Taxonomy`
-      - **Data Entity**: `TaxonomyItem`
+  - **Foreign Namespace**: `Semantics` (defined elsewhere)
+    - **Data Model**: `Semantics`
+      - **Data Entity**: `SemanticsItem`
 
 ### Key Relationships
 
-- **Namespace-Model**: A `DataNamespace` contains `DataModel` instances.
-- **Model-Entity**: A `DataModel` contains `DataEntity` instances.
-- **Entity-Property**: A `DataEntity` has `DataProperty` instances.
-- **Entity-Association**: A `DataEntity` has `DataAssociation` instances.
-- **Entity-Parent**: A `DataEntity` can have `DataEntity` instances as parents.
-- **Namespace-Foreign**: A `DataNamespace` can have references to `DataNamespace` instances.
+- **Namespace-Model**: A `DomainNamespace` contains `DomainModel` instances.
+- **Model-Entity**: A `DomainModel` contains `DomainEntity` instances.
+- **Entity-Property**: A `DomainEntity` has `DomainProperty` instances.
+- **Entity-Association**: A `DomainEntity` has `DomainAssociation` instances.
+- **Entity-Parent**: A `DomainEntity` can have `DomainEntity` instances as parents.
+- **Namespace-Foreign**: A `DomainNamespace` can have references to `DomainNamespace` instances.
 
 ## Summary
 

package/src/models/CertificateFile.ts

@@ -11,18 +11,12 @@ export interface ICertificateFile extends IFile {
 export class CertificateFile extends File {
   override kind = CertificateFileKind
 
-  static fromCertificate(
-    certificate: ICertificate | Certificate,
-    organization: string,
-    owner?: string
-  ): CertificateFile {
+  static fromCertificate(certificate: ICertificate | Certificate): CertificateFile {
     const init: ICertificateFile = {
       kind: CertificateFileKind,
       key: certificate.key,
-      organization,
       info: Thing.fromName(certificate.name).toJSON(),
-      lastModified: { user: owner || '', time: 0, byMe: false },
-      owner,
+      lastModified: { user: '', time: 0, byMe: false },
       parents: [],
       permissionIds: [],
       permissions: [],
@@ -32,10 +26,9 @@ export class CertificateFile extends File {
 
   /**
    * @param name The name to set.
-   * @param owner The user id that is the owner of the file.
    */
-  static override fromName(name: string, organization: string, owner?: string): CertificateFile {
-    return super.fromName(name, organization, owner, CertificateFileKind) as CertificateFile
+  static override fromName(name: string): CertificateFile {
+    return super.fromName(name, CertificateFileKind) as CertificateFile
   }
 
   constructor(input?: string | ICertificateFile) {
@@ -49,7 +42,6 @@ export class CertificateFile extends File {
       init = {
         kind: CertificateFileKind,
         key: nanoid(),
-        organization: '',
         info: Thing.fromName('').toJSON(),
         parents: [],
         permissionIds: [],

package/src/models/Folder.ts

@@ -20,10 +20,9 @@ export class Folder extends File {
    * Creates a new Folder object from a name.
    *
    * @param name The name to set.
-   * @param owner The user id that is the owner of the folder.
    */
-  static override fromName(name: string, organization: string, owner?: string): Folder {
-    return super.fromName(name, organization, owner, FolderKind) as Folder
+  static override fromName(name: string): Folder {
+    return super.fromName(name, FolderKind) as Folder
   }
 
   /**
@@ -40,7 +39,6 @@ export class Folder extends File {
       init = {
         kind: FolderKind,
         key: nanoid(),
-        organization: '',
         info: Thing.fromName('').toJSON(),
         parents: [],
         permissionIds: [],

package/src/models/Project.ts

@@ -19,7 +19,7 @@ export interface IProject extends IFile {
 export class Project extends File {
   override kind = ProjectKind
 
-  static fromProject(project: HttpProject | IHttpProject, organization: string, owner?: string): Project {
+  static fromProject(project: HttpProject | IHttpProject): Project {
     let final: IHttpProject
     if (typeof (project as HttpProject).toJSON === 'function') {
       final = (project as HttpProject).toJSON()
@@ -29,10 +29,8 @@ export class Project extends File {
     const init: IProject = {
       kind: ProjectKind,
       key: project.key,
-      organization,
       info: { ...final.info },
-      lastModified: { user: owner || '', time: 0, byMe: false },
-      owner,
+      lastModified: { user: '', time: 0, byMe: false },
       parents: [],
       permissionIds: [],
       permissions: [],
@@ -42,10 +40,9 @@ export class Project extends File {
 
   /**
    * @param name The name to set.
-   * @param owner The user id that is the owner of the file.
    */
-  static override fromName(name: string, organization: string, owner?: string): Project {
-    return super.fromName(name, organization, owner, ProjectKind) as Project
+  static override fromName(name: string): Project {
+    return super.fromName(name, ProjectKind) as Project
   }
 
   constructor(input?: string | IProject) {
@@ -59,7 +56,6 @@ export class Project extends File {
       init = {
         kind: ProjectKind,
         key: nanoid(),
-        organization: '',
         info: Thing.fromName('').toJSON(),
         parents: [],
         permissionIds: [],