@api-client/core 0.16.0 → 0.17.0

package/build/src/modeling/Semantics.d.ts

@@ -202,6 +202,43 @@ export declare enum SemanticScope {
      */
     Association = "Association"
 }
+/**
+ * Defines categories for organizing semantics in the UI.
+ */
+export declare enum SemanticCategory {
+    /**
+     * User management, authentication, and access control
+     */
+    Identity = "Identity & Authentication",
+    /**
+     * Timestamps, versioning, and record lifecycle
+     */
+    Lifecycle = "Timestamps & Versioning",
+    /**
+     * Text content, media, and rich content types
+     */
+    Content = "Content & Media",
+    /**
+     * Business-specific data like pricing, inventory, status
+     */
+    Business = "Business Data",
+    /**
+     * Contact information and communication
+     */
+    Contact = "Contact Information",
+    /**
+     * Organization, categorization, and tagging
+     */
+    Organization = "Classification & Organization",
+    /**
+     * Location and geographical data
+     */
+    Location = "Location & Geography",
+    /**
+     * Calculated and derived values
+     */
+    Computed = "Computed Values"
+}
 /**
  * A base interface for all Data Semantics, containing common properties.
  * A semantic is an annotation applied to a Data Entity, Property, or Association
@@ -225,6 +262,10 @@ interface BaseDataSemantic {
      * Specifies whether the semantic applies to an Entity, Property, or Association.
      */
     scope: SemanticScope;
+    /**
+     * The category this semantic belongs to for UI organization.
+     */
+    category: SemanticCategory;
 }
 /**
  * Represents a semantic that can be applied to an entire Data Entity.
@@ -270,6 +311,17 @@ export type DataSemantic = EntitySemantic | PropertySemantic | AssociationSemant
  * This acts as a central registry for the application.
  */
 export declare const DataSemantics: Record<SemanticType, DataSemantic>;
+/**
+ * Helper function to get all semantics grouped by category.
+ * Useful for organizing semantics in UI dropdowns and forms.
+ */
+export declare const getSemanticsByCategory: () => Record<SemanticCategory, DataSemantic[]>;
+/**
+ * Helper function to get semantics for a specific category.
+ * @param category The category to filter by
+ * @returns Array of semantics in the specified category
+ */
+export declare const getSemanticsByCategoryType: (category: SemanticCategory) => DataSemantic[];
 /**
  * Represents the application of a data semantic to a specific
  * entity or property within a user's data model.

package/build/src/modeling/Semantics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Semantics.d.ts","sourceRoot":"","sources":["../../../src/modeling/Semantics.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Semantics.d.ts","sourceRoot":"","sources":["../../../src/modeling/Semantics.ts"],"names":[],"mappings":"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"}

package/build/src/modeling/Semantics.js

@@ -212,6 +212,44 @@ export var SemanticScope;
      */
     SemanticScope["Association"] = "Association";
 })(SemanticScope || (SemanticScope = {}));
+/**
+ * Defines categories for organizing semantics in the UI.
+ */
+export var SemanticCategory;
+(function (SemanticCategory) {
+    /**
+     * User management, authentication, and access control
+     */
+    SemanticCategory["Identity"] = "Identity & Authentication";
+    /**
+     * Timestamps, versioning, and record lifecycle
+     */
+    SemanticCategory["Lifecycle"] = "Timestamps & Versioning";
+    /**
+     * Text content, media, and rich content types
+     */
+    SemanticCategory["Content"] = "Content & Media";
+    /**
+     * Business-specific data like pricing, inventory, status
+     */
+    SemanticCategory["Business"] = "Business Data";
+    /**
+     * Contact information and communication
+     */
+    SemanticCategory["Contact"] = "Contact Information";
+    /**
+     * Organization, categorization, and tagging
+     */
+    SemanticCategory["Organization"] = "Classification & Organization";
+    /**
+     * Location and geographical data
+     */
+    SemanticCategory["Location"] = "Location & Geography";
+    /**
+     * Calculated and derived values
+     */
+    SemanticCategory["Computed"] = "Computed Values";
+})(SemanticCategory || (SemanticCategory = {}));
 /**
  * A type guard to check if a semantic is an EntitySemantic.
  */
@@ -230,205 +268,276 @@ export const isAssociationSemantic = (semantic) => semantic.scope === SemanticSc
  */
 export const DataSemantics = {
     //
-    // Entity-Level Definitions
+    // Identity & Authentication
     //
     [SemanticType.User]: {
         id: SemanticType.User,
         displayName: 'User Entity',
         scope: SemanticScope.Entity,
-        description: 'Designates an entity that represents system users, crucial for authentication and authorization.',
+        description: 'System users and accounts',
+        category: SemanticCategory.Identity,
     },
-    //
-    // Property-Level Definitions
-    //
     [SemanticType.Password]: {
         id: SemanticType.Password,
         displayName: 'User Password',
         scope: SemanticScope.Property,
-        description: 'Annotates the field as the user password. The runtime should treat this field with special care, ensuring it is encrypted and not exposed in API responses.',
+        description: 'Secure password field',
+        category: SemanticCategory.Identity,
+        applicableDataTypes: ['string'],
+    },
+    [SemanticType.UserRole]: {
+        id: SemanticType.UserRole,
+        displayName: 'User Role Field',
+        scope: SemanticScope.Property,
+        description: 'User permissions and access level',
+        category: SemanticCategory.Identity,
         applicableDataTypes: ['string'],
     },
+    [SemanticType.ResourceOwnerIdentifier]: {
+        id: SemanticType.ResourceOwnerIdentifier,
+        displayName: 'Resource Owner Identifier',
+        scope: SemanticScope.Association,
+        description: 'Links record to owner user',
+        category: SemanticCategory.Identity,
+    },
+    //
+    // Timestamps & Versioning
+    //
     [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.",
+        description: 'When record was created',
+        category: SemanticCategory.Lifecycle,
         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.",
+        description: 'When record was last modified',
+        category: SemanticCategory.Lifecycle,
         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.",
+        description: 'When record was marked deleted',
+        category: SemanticCategory.Lifecycle,
         applicableDataTypes: ['datetime'],
     },
-    [SemanticType.PublicUniqueName]: {
-        id: SemanticType.PublicUniqueName,
-        displayName: 'Public Unique Name (Slug)',
+    [SemanticType.DeletedFlag]: {
+        id: SemanticType.DeletedFlag,
+        displayName: 'Soft Delete Flag',
         scope: SemanticScope.Property,
-        description: 'A user-friendly, unique public identifier for a resource, often used in URLs.',
-        applicableDataTypes: ['string'],
+        description: 'Mark record as deleted',
+        category: SemanticCategory.Lifecycle,
+        applicableDataTypes: ['boolean'],
     },
+    [SemanticType.Version]: {
+        id: SemanticType.Version,
+        displayName: 'Version Number',
+        scope: SemanticScope.Property,
+        description: 'Auto-incrementing version counter',
+        category: SemanticCategory.Lifecycle,
+        applicableDataTypes: ['number'],
+    },
+    //
+    // Content & Media
+    //
     [SemanticType.Title]: {
         id: SemanticType.Title,
         displayName: 'Record Title',
         scope: SemanticScope.Property,
-        description: 'A title for the record. Used as a source for the PublicUniqueName semantic.',
+        description: 'Main title or heading',
+        category: SemanticCategory.Content,
         applicableDataTypes: ['string'],
     },
-    [SemanticType.UserRole]: {
-        id: SemanticType.UserRole,
-        displayName: 'User Role Field',
+    [SemanticType.Description]: {
+        id: SemanticType.Description,
+        displayName: 'Description',
         scope: SemanticScope.Property,
-        description: "A text or enum field that defines the user's role for role-based authorization.",
+        description: 'Detailed description text',
+        category: SemanticCategory.Content,
         applicableDataTypes: ['string'],
     },
-    [SemanticType.Status]: {
-        id: SemanticType.Status,
-        displayName: 'Record Status',
+    [SemanticType.Summary]: {
+        id: SemanticType.Summary,
+        displayName: 'Summary',
         scope: SemanticScope.Property,
-        description: 'A text or enum field to represent the state of a record.',
+        description: 'Brief summary text',
+        category: SemanticCategory.Content,
         applicableDataTypes: ['string'],
     },
-    [SemanticType.Version]: {
-        id: SemanticType.Version,
-        displayName: 'Version Number',
+    [SemanticType.Markdown]: {
+        id: SemanticType.Markdown,
+        displayName: 'Markdown Content',
         scope: SemanticScope.Property,
-        description: 'An integer field that automatically increments on every update.',
-        applicableDataTypes: ['number'],
+        description: 'Formatted text content',
+        category: SemanticCategory.Content,
+        applicableDataTypes: ['string'],
+    },
+    [SemanticType.HTML]: {
+        id: SemanticType.HTML,
+        displayName: 'HTML Content',
+        scope: SemanticScope.Property,
+        description: 'Rich HTML content',
+        category: SemanticCategory.Content,
+        applicableDataTypes: ['string'],
     },
     [SemanticType.ImageURL]: {
         id: SemanticType.ImageURL,
         displayName: 'Image URL',
         scope: SemanticScope.Property,
-        description: 'Annotates a field that holds a reference to an image data via an URL.',
+        description: 'Link to image file',
+        category: SemanticCategory.Content,
         applicableDataTypes: ['string'],
     },
     [SemanticType.FileURL]: {
         id: SemanticType.FileURL,
         displayName: 'File URL',
         scope: SemanticScope.Property,
-        description: 'Annotates a field that holds a reference to a file object via an URL (non-image binary data).',
+        description: 'Link to file attachment',
+        category: SemanticCategory.Content,
         applicableDataTypes: ['string'],
     },
-    [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.Markdown]: {
-        id: SemanticType.Markdown,
-        displayName: 'Markdown Content',
+    //
+    // Business Data
+    //
+    [SemanticType.Status]: {
+        id: SemanticType.Status,
+        displayName: 'Record Status',
         scope: SemanticScope.Property,
-        description: 'A text field that contains markdown content.',
+        description: 'Current state of record',
+        category: SemanticCategory.Business,
         applicableDataTypes: ['string'],
     },
-    [SemanticType.HTML]: {
-        id: SemanticType.HTML,
-        displayName: 'HTML Content',
+    [SemanticType.Price]: {
+        id: SemanticType.Price,
+        displayName: 'Price',
         scope: SemanticScope.Property,
-        description: 'Annotates a field that contains HTML content.',
-        applicableDataTypes: ['string'],
+        description: 'Monetary value with currency',
+        category: SemanticCategory.Business,
+        applicableDataTypes: ['number', 'string'],
     },
-    [SemanticType.GeospatialCoordinates]: {
-        id: SemanticType.GeospatialCoordinates,
-        displayName: 'Geospatial Coordinates',
+    [SemanticType.SKU]: {
+        id: SemanticType.SKU,
+        displayName: 'SKU',
         scope: SemanticScope.Property,
-        description: 'Annotates a field that holds geospatial coordinate data (latitude/longitude).',
+        description: 'Product identification code',
+        category: SemanticCategory.Business,
         applicableDataTypes: ['string'],
     },
+    //
+    // Contact Information
+    //
     [SemanticType.Email]: {
         id: SemanticType.Email,
         displayName: 'Email',
         scope: SemanticScope.Property,
-        description: 'Annotates a field as an email address with validation and verification options.',
+        description: 'Email address',
+        category: SemanticCategory.Contact,
         applicableDataTypes: ['string'],
     },
     [SemanticType.Phone]: {
         id: SemanticType.Phone,
         displayName: 'Phone',
         scope: SemanticScope.Property,
-        description: 'Annotates a field as a phone number with validation and formatting options.',
+        description: 'Phone number',
+        category: SemanticCategory.Contact,
         applicableDataTypes: ['string'],
     },
-    [SemanticType.Price]: {
-        id: SemanticType.Price,
-        displayName: 'Price',
-        scope: SemanticScope.Property,
-        description: 'Annotates a field as a monetary value with currency support and precision control.',
-        applicableDataTypes: ['number', 'string'],
-    },
     [SemanticType.URL]: {
         id: SemanticType.URL,
         displayName: 'URL',
         scope: SemanticScope.Property,
-        description: 'Annotates a field as a URL with validation and allowed protocols.',
+        description: 'Web address or link',
+        category: SemanticCategory.Contact,
         applicableDataTypes: ['string'],
     },
-    [SemanticType.SKU]: {
-        id: SemanticType.SKU,
-        displayName: 'SKU',
+    //
+    // Classification & Organization
+    //
+    [SemanticType.PublicUniqueName]: {
+        id: SemanticType.PublicUniqueName,
+        displayName: 'Public Unique Name (Slug)',
         scope: SemanticScope.Property,
-        description: 'Annotates a field as a Stock Keeping Unit (SKU). Enforces uniqueness at the database level, critical for product catalogs. Provides automatic validation and formatting for product identification codes.',
+        description: 'URL-friendly unique identifier',
+        category: SemanticCategory.Organization,
         applicableDataTypes: ['string'],
     },
-    [SemanticType.Description]: {
-        id: SemanticType.Description,
-        displayName: 'Description',
-        scope: SemanticScope.Property,
-        description: 'Annotates a field as a long-form description.',
-        applicableDataTypes: ['string'],
+    [SemanticType.Tags]: {
+        id: SemanticType.Tags,
+        displayName: 'Tags',
+        scope: SemanticScope.Association,
+        description: 'Enable tagging functionality',
+        category: SemanticCategory.Organization,
     },
-    [SemanticType.Summary]: {
-        id: SemanticType.Summary,
-        displayName: 'Summary',
+    [SemanticType.Categories]: {
+        id: SemanticType.Categories,
+        displayName: 'Categories',
+        scope: SemanticScope.Association,
+        description: 'Enable categorization functionality',
+        category: SemanticCategory.Organization,
+    },
+    //
+    // Location & Geography
+    //
+    [SemanticType.GeospatialCoordinates]: {
+        id: SemanticType.GeospatialCoordinates,
+        displayName: 'Geospatial Coordinates',
         scope: SemanticScope.Property,
-        description: 'Annotates a field as a short summary.',
+        description: 'Location coordinates',
+        category: SemanticCategory.Location,
         applicableDataTypes: ['string'],
     },
+    //
+    // Computed Values
+    //
     [SemanticType.Calculated]: {
         id: SemanticType.Calculated,
         displayName: 'Calculated',
         scope: SemanticScope.Property,
-        description: 'Annotates a field as a calculated value based on a formula.',
+        description: 'Auto-calculated field value',
+        category: SemanticCategory.Computed,
         applicableDataTypes: ['string'],
     },
     [SemanticType.Derived]: {
         id: SemanticType.Derived,
         displayName: 'Derived',
         scope: SemanticScope.Property,
-        description: 'Annotates a field as derived from other fields.',
+        description: 'Value derived from other fields',
+        category: SemanticCategory.Computed,
         applicableDataTypes: ['string'],
     },
-    //
-    // Association-Level Definitions
-    //
-    [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.Tags]: {
-        id: SemanticType.Tags,
-        displayName: 'Tags',
-        scope: SemanticScope.Association,
-        description: 'Annotates an association as supporting tag functionality.',
-    },
-    [SemanticType.Categories]: {
-        id: SemanticType.Categories,
-        displayName: 'Categories',
-        scope: SemanticScope.Association,
-        description: 'Annotates an association as supporting category functionality.',
-    },
+};
+/**
+ * Helper function to get all semantics grouped by category.
+ * Useful for organizing semantics in UI dropdowns and forms.
+ */
+export const getSemanticsByCategory = () => {
+    const result = {
+        [SemanticCategory.Identity]: [],
+        [SemanticCategory.Lifecycle]: [],
+        [SemanticCategory.Content]: [],
+        [SemanticCategory.Business]: [],
+        [SemanticCategory.Contact]: [],
+        [SemanticCategory.Organization]: [],
+        [SemanticCategory.Location]: [],
+        [SemanticCategory.Computed]: [],
+    };
+    Object.values(DataSemantics).forEach((semantic) => {
+        result[semantic.category].push(semantic);
+    });
+    return result;
+};
+/**
+ * Helper function to get semantics for a specific category.
+ * @param category The category to filter by
+ * @returns Array of semantics in the specified category
+ */
+export const getSemanticsByCategoryType = (category) => {
+    return Object.values(DataSemantics).filter((semantic) => semantic.category === category);
 };
 //# sourceMappingURL=Semantics.js.map