@rebasepro/types 0.1.2 → 0.2.1

package/src/types/properties.ts

@@ -2,7 +2,7 @@ import React from "react";
 
 import type { ComponentRef } from "./component_ref";
 
-import type { EntityReference, EntityRelation, EntityValues, GeoPoint, Entity } from "./entities";
+import type { EntityReference, EntityRelation, EntityValues, GeoPoint, Entity, Vector } from "./entities";
 import type { Relation, JoinStep, OnAction } from "./relations";
 import type { EntityCollection, FilterValues } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
@@ -48,7 +48,9 @@ export type DataType =
     | "reference"
     | "relation"
     | "array"
-    | "map";
+    | "map"
+    | "vector"
+    | "binary";
 
 export type Property =
     | StringProperty
@@ -59,7 +61,9 @@ export type Property =
     | ReferenceProperty
     | RelationProperty
     | ArrayProperty
-    | MapProperty;
+    | MapProperty
+    | VectorProperty
+    | BinaryProperty;
 
 export type Properties = {
     [key: string]: Property;
@@ -89,6 +93,8 @@ export type InferPropertyType<P extends Property> =
     P extends RelationProperty ? EntityRelation | EntityRelation[] :
     P extends ArrayProperty ? (P["of"] extends Property ? InferPropertyType<P["of"]>[] : unknown[]) :
     P extends MapProperty ? (P["properties"] extends Properties ? InferEntityType<P["properties"]> : Record<string, unknown>) :
+    P extends VectorProperty ? Vector :
+    P extends BinaryProperty ? string :
     never;
 
 /**
@@ -185,6 +191,8 @@ export interface BaseProperty<CustomProps = unknown> {
 
 
 
+
+
     /**
      * Rules for validating this property
      */
@@ -378,6 +386,28 @@ export interface BooleanProperty extends BaseProperty {
     validation?: PropertyValidationSchema;
 }
 
+/**
+ * @group Entity properties
+ */
+export interface VectorUIConfig extends BaseUIConfig {
+    clearable?: boolean;
+}
+
+export interface VectorProperty extends BaseProperty {
+    ui?: VectorUIConfig;
+    type: "vector";
+    dimensions: number;
+    validation?: PropertyValidationSchema;
+}
+
+/**
+ * @group Entity properties
+ */
+export interface BinaryProperty extends BaseProperty {
+    type: "binary";
+    validation?: PropertyValidationSchema;
+}
+
 /**
  * @group Entity properties
  */
@@ -503,7 +533,7 @@ export interface RelationProperty extends BaseProperty {
      * When set, the framework treats this property as a self-contained relation
      * definition and no separate `relations[]` entry is needed.
      */
-    target?: () => EntityCollection;
+    target?: string | (() => EntityCollection | string);
 
     /**
      * Whether this property references one or many records.

package/src/types/property_config.d.ts

@@ -0,0 +1,70 @@
+import React from "react";
+import { ArrayProperty, MapProperty, StringProperty, NumberProperty, BooleanProperty, DateProperty, GeopointProperty, ReferenceProperty, RelationProperty } from "./properties";
+import { BaseProperty } from "./properties";
+type CMSBasePropertyNoName = Omit<BaseProperty, "name">;
+export type ConfigProperty = (Omit<StringProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<NumberProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<BooleanProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<DateProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<GeopointProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<ReferenceProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<RelationProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<ArrayProperty, "name" | "of" | "oneOf"> & {
+    name?: string;
+    of?: ConfigProperty | ConfigProperty[];
+    oneOf?: {
+        properties: Record<string, ConfigProperty>;
+        typeField?: string;
+        valueField?: string;
+        propertiesOrder?: string[];
+    };
+} & CMSBasePropertyNoName) | (Omit<MapProperty, "name" | "properties"> & {
+    name?: string;
+    properties?: Record<string, ConfigProperty>;
+} & CMSBasePropertyNoName);
+/**
+ * This is the configuration object for a property.
+ * These configs are generated by default for the properties defined in your
+ * collections' configuration, but you can define your own to be used.
+ */
+export type PropertyConfig = {
+    /**
+     * Key used to identify this property config.
+     */
+    key: PropertyConfigId | string;
+    /**
+     * Name of this field type.
+     * This is not the name of the property.
+     */
+    name: string;
+    /**
+     * Default config for the property.
+     * This property or builder will be used as the base values for the resulting property.
+     * You can also use a builder function to generate the base property.
+     */
+    property: ConfigProperty;
+    /**
+     * Optional icon to be used in the field selector.
+     * Use a 24x24 component, in order not to break the layout.
+     * Any Rebase icon can be used.
+     */
+    Icon?: React.ComponentType;
+    /**
+     * CSS color, used only in some plugins like the field selector.
+     * e.g. "#2d7ff9"
+     */
+    color?: string;
+    /**
+     * Description of this field type.
+     */
+    description?: string;
+};
+export type PropertyConfigId = "text_field" | "multiline" | "markdown" | "url" | "email" | "user_select" | "select" | "multi_select" | "number_input" | "number_select" | "multi_number_select" | "file_upload" | "multi_file_upload" | "group" | "key_value" | "reference" | "reference_as_string" | "multi_references" | "relation" | "switch" | "date_time" | "repeat" | "custom_array" | "block";
+export {};

package/src/types/property_config.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { ArrayProperty, MapProperty, Property, StringProperty, NumberProperty, BooleanProperty, DateProperty, GeopointProperty, ReferenceProperty, RelationProperty } from "./properties";import { BaseProperty } from "./properties";
+import { ArrayProperty, MapProperty, Property, StringProperty, NumberProperty, BooleanProperty, DateProperty, GeopointProperty, ReferenceProperty, RelationProperty, VectorProperty, BinaryProperty } from "./properties";import { BaseProperty } from "./properties";
 
 type CMSBasePropertyNoName = Omit<BaseProperty, "name">;
 
@@ -19,7 +19,9 @@ export type ConfigProperty =
     | (Omit<MapProperty, "name" | "properties"> & {
         name?: string;
         properties?: Record<string, ConfigProperty>
-    } & CMSBasePropertyNoName);
+    } & CMSBasePropertyNoName)
+    | (Omit<VectorProperty, "name"> & { name?: string } & CMSBasePropertyNoName)
+    | (Omit<BinaryProperty, "name"> & { name?: string } & CMSBasePropertyNoName);
 
 /**
  * This is the configuration object for a property.
@@ -90,4 +92,5 @@ export type PropertyConfigId =
     "date_time" |
     "repeat" |
     "custom_array" |
-    "block";
+    "block" |
+    "vector_input";

package/src/types/relations.d.ts

@@ -0,0 +1,336 @@
+import type { EntityCollection } from "./collections";
+/**
+ * @group Models
+ */
+export type OnAction = "cascade" | "restrict" | "no action" | "set null" | "set default";
+/**
+ * Extended relation that combines base relation with Rebase UI config
+ * @group Models
+ */
+export interface Relation {
+    /**
+     * The application-level name for this relationship.
+     * If not provided, it will be inferred from the target collection path.
+     * @example "posts"
+     */
+    relationName?: string;
+    /**
+     * The final collection you want to retrieve records from.
+     */
+    target: () => EntityCollection;
+    /**
+     * The nature of the relationship, determining if one or many records are returned.
+     */
+    cardinality: "one" | "many";
+    /**
+     * Which side owns the persistence for this relationship.
+     * - "owning": The foreign key (for one-to-one/many-to-one) or the junction table (for many-to-many) is managed by this collection.
+     * - "inverse": The foreign key is on the target collection's table. This side of the relation is typically read-only.
+     * Defaults to "owning".
+     */
+    direction?: "owning" | "inverse";
+    /**
+     * The name of the inverse relation.
+     * This is only needed when the inverse relation is not the same as the relation name.
+     * For example, if the relation name is "posts", the inverse relation name might be "author".
+     */
+    inverseRelationName?: string;
+    /**
+     * Column on THIS table that stores the foreign key to the target.
+     * Required when `direction` is "owning" and `cardinality` is "one".
+     * @example "author_id"
+     */
+    localKey?: string;
+    /**
+     * Column on the TARGET table that stores the foreign key to this entity.
+     * Required when `direction` is "inverse".
+     * @example "post_id"
+     */
+    foreignKeyOnTarget?: string;
+    /**
+     * Defines the junction table for a many-to-many relationship.
+     * Required when `cardinality` is "many" and `direction` is "owning".
+     *
+     * @example Simple many-to-many between Users and Roles:
+     * ```typescript
+     * // Users collection
+     * {
+     *   relations: [{
+     *     relationName: "roles",
+     *     target: () => rolesCollection,
+     *     cardinality: "many",
+     *     through: {
+     *       table: "user_roles",        // Junction table name
+     *       sourceColumn: "user_id",    // Column that references this collection's ID
+     *       targetColumn: "role_id"     // Column that references target collection's ID
+     *     }
+     *   }]
+     * }
+     *
+     * // This creates a junction table like:
+     * // CREATE TABLE user_roles (
+     * //   user_id INTEGER REFERENCES users(id),
+     * //   role_id INTEGER REFERENCES roles(id),
+     * //   PRIMARY KEY (user_id, role_id)
+     * // );
+     * ```
+     *
+     * @example Many-to-many with additional junction table data:
+     * ```typescript
+     * // Students and Courses with enrollment date
+     * {
+     *   relations: [{
+     *     relationName: "courses",
+     *     target: () => coursesCollection,
+     *     cardinality: "many",
+     *     through: {
+     *       table: "enrollments",
+     *       sourceColumn: "student_id",
+     *       targetColumn: "course_id"
+     *     }
+     *   }]
+     * }
+     *
+     * // Junction table can have additional columns:
+     * // CREATE TABLE enrollments (
+     * //   student_id INTEGER REFERENCES students(id),
+     * //   course_id INTEGER REFERENCES courses(id),
+     * //   enrolled_at TIMESTAMP DEFAULT NOW(),
+     * //   grade VARCHAR(2),
+     * //   PRIMARY KEY (student_id, course_id)
+     * // );
+     * ```
+     */
+    through?: {
+        table: string;
+        sourceColumn: string;
+        targetColumn: string;
+    };
+    /**
+     * An explicit, ordered array of JOINs to perform to get from the source
+     * to the target. Used for multi-hop relations, composite keys, or when you need
+     * fine-grained control over the join logic.
+     *
+     * When `joinPath` is provided, it overrides all other relation configuration
+     * (localKey, foreignKeyOnTarget, through) and gives you complete control
+     * over how tables are joined together.
+     *
+     * @example Simple one-to-one join (equivalent to localKey):
+     * ```typescript
+     * // Posts -> Authors relationship
+     * {
+     *   relationName: "author",
+     *   target: () => authorsCollection,
+     *   cardinality: "one",
+     *   joinPath: [
+     *     {
+     *       table: "authors",
+     *       on: {
+     *         from: "author_id",  // Column on posts table
+     *         to: "id"           // Column on authors table
+     *       }
+     *     }
+     *   ]
+     * }
+     *
+     * // Generates: SELECT * FROM posts JOIN authors ON posts.author_id = authors.id
+     * ```
+     *
+     * @example Multi-hop relationship (3 tables):
+     * ```typescript
+     * // Users -> Permissions through Roles
+     * {
+     *   relationName: "permissions",
+     *   target: () => permissionsCollection,
+     *   cardinality: "many",
+     *   joinPath: [
+     *     {
+     *       table: "user_roles",
+     *       on: {
+     *         from: "id",        // users.id
+     *         to: "user_id"      // user_roles.user_id
+     *       }
+     *     },
+     *     {
+     *       table: "roles",
+     *       on: {
+     *         from: "role_id",   // user_roles.role_id
+     *         to: "id"          // roles.id
+     *       }
+     *     },
+     *     {
+     *       table: "role_permissions",
+     *       on: {
+     *         from: "id",        // roles.id
+     *         to: "role_id"      // role_permissions.role_id
+     *       }
+     *     },
+     *     {
+     *       table: "permissions",
+     *       on: {
+     *         from: "permission_id", // role_permissions.permission_id
+     *         to: "id"              // permissions.id
+     *       }
+     *     }
+     *   ]
+     * }
+     *
+     * // Generates:
+     * // SELECT * FROM users
+     * // JOIN user_roles ON users.id = user_roles.user_id
+     * // JOIN roles ON user_roles.role_id = roles.id
+     * // JOIN role_permissions ON roles.id = role_permissions.role_id
+     * // JOIN permissions ON role_permissions.permission_id = permissions.id
+     * ```
+     *
+     * @example Composite key relationship:
+     * ```typescript
+     * // Orders -> Customer by company_code + region
+     * {
+     *   relationName: "customer",
+     *   target: () => customersCollection,
+     *   cardinality: "one",
+     *   joinPath: [
+     *     {
+     *       table: "customers",
+     *       on: {
+     *         from: ["company_code", "region_id"], // Multiple columns from orders
+     *         to: ["code", "region_id"]            // Multiple columns on customers
+     *       }
+     *     }
+     *   ]
+     * }
+     *
+     * // Generates:
+     * // SELECT * FROM orders
+     * // JOIN customers ON orders.company_code = customers.code
+     * //               AND orders.region_id = customers.region_id
+     * ```
+     *
+     * @example Self-referencing with intermediate table:
+     * ```typescript
+     * // Users -> Friends (many-to-many self-reference)
+     * {
+     *   relationName: "friends",
+     *   target: () => usersCollection, // Same collection
+     *   cardinality: "many",
+     *   joinPath: [
+     *     {
+     *       table: "friendships",
+     *       on: {
+     *         from: "id",         // users.id
+     *         to: "user_id"       // friendships.user_id
+     *       }
+     *     },
+     *     {
+     *       table: "users",
+     *       on: {
+     *         from: "friend_id",  // friendships.friend_id
+     *         to: "id"           // users.id (target)
+     *       }
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * @example Complex business logic join:
+     * ```typescript
+     * // Products -> Active Suppliers (only current, non-expired contracts)
+     * {
+     *   relationName: "activeSuppliers",
+     *   target: () => suppliersCollection,
+     *   cardinality: "many",
+     *   joinPath: [
+     *     {
+     *       table: "product_supplier_contracts",
+     *       on: {
+     *         from: "id",           // products.id
+     *         to: "product_id"      // contracts.product_id
+     *       }
+     *     },
+     *     {
+     *       table: "suppliers",
+     *       on: {
+     *         from: "supplier_id",  // contracts.supplier_id
+     *         to: "id"             // suppliers.id
+     *       }
+     *     }
+     *   ]
+     *   // Note: Additional WHERE conditions for active/non-expired
+     *   // would be handled in the query logic, not in joinPath
+     * }
+     * ```
+     */
+    joinPath?: JoinStep[];
+    /**
+     * Action to perform on update.
+     */
+    onUpdate?: OnAction;
+    /**
+     * Action to perform on delete.
+     */
+    onDelete?: OnAction;
+    overrides?: Partial<EntityCollection>;
+    validation?: {
+        required?: boolean;
+    };
+}
+/**
+ * Defines a single, explicit step in a multi-join path.
+ *
+ * Each step represents one JOIN operation in the sequence. The `from` columns
+ * refer to the previous table in the chain (or the source table for the first step),
+ * and the `to` columns refer to the current table being joined.
+ *
+ * @example Single column join:
+ * ```typescript
+ * {
+ *   table: "authors",
+ *   on: {
+ *     from: "author_id",  // Column from previous table (e.g., posts.author_id)
+ *     to: "id"           // Column from current table (authors.id)
+ *   }
+ * }
+ * ```
+ *
+ * @example Multi-column composite key join:
+ * ```typescript
+ * {
+ *   table: "order_items",
+ *   on: {
+ *     from: ["order_id", "store_id"],    // Multiple columns from previous table
+ *     to: ["order_id", "store_id"]       // Corresponding columns in current table
+ *   }
+ * }
+ * ```
+ */
+export interface JoinStep {
+    /**
+     * The database table name to join TO in this step.
+     * This is the table you're joining into, not the table you're joining from.
+     *
+     * @example "authors", "user_roles", "product_categories"
+     */
+    table: string;
+    /**
+     * The join condition for this step. Defines how the previous table
+     * connects to the current table.
+     *
+     * - `from`: Column name(s) on the PREVIOUS table in the join chain
+     * - `to`: Column name(s) on the CURRENT table (specified in `table`)
+     *
+     * For the first step, `from` refers to the source collection's table.
+     * For subsequent steps, `from` refers to the table from the previous step.
+     *
+     * Both `from` and `to` support:
+     * - Single column: `"user_id"`
+     * - Multiple columns: `["company_id", "region_id"]` for composite keys
+     *
+     * When using arrays, both `from` and `to` must have the same length,
+     * and columns are matched by position (index 0 with index 0, etc.).
+     */
+    on: {
+        from: string | string[];
+        to: string | string[];
+    };
+}

package/src/types/relations.ts

@@ -20,7 +20,7 @@ export interface Relation {
     /**
      * The final collection you want to retrieve records from.
      */
-    target: () => EntityCollection;
+    target: (() => EntityCollection) | any;
 
     /**
      * The nature of the relationship, determining if one or many records are returned.