@firecms/core 3.0.0-alpha.26 → 3.0.0-alpha.28

package/src/types/datasource.ts

@@ -1,6 +1,6 @@
-import { Entity, EntityStatus, EntityValues } from "./entities";
+import { Entity, EntityReference, EntityStatus, EntityValues, GeoPoint } from "./entities";
 import { EntityCollection, FilterValues } from "./collections";
-import { ResolvedEntityCollection, ResolvedProperty } from "./resolved_entities";
+import { ResolvedEntityCollection } from "./resolved_entities";
 
 /**
  * @category Datasource
@@ -198,7 +198,6 @@ export interface DataSource {
         path: string,
         name: string,
         value: any,
-        property: ResolvedProperty,
         entityId?: string
     ): Promise<boolean>;
 
@@ -214,12 +213,177 @@ export interface DataSource {
 
     /**
      * Check if the given filter combination is valid
-     * @param params
+     * @param props
      */
-    isFilterCombinationValid?(params: {
-        path: string,
-        collection: EntityCollection<any>,
-        filterValues: FilterValues<any>,
-        sortBy?: [string, "asc" | "desc"]
-    }): boolean;
+    isFilterCombinationValid?(props: FilterCombinationValidProps): boolean;
+}
+
+export type FilterCombinationValidProps = {
+    path: string;
+    collection: EntityCollection<any>;
+    filterValues: FilterValues<any>;
+    sortBy?: [string, "asc" | "desc"];
+};
+
+export type SaveEntityDelegateProps<M extends Record<string, any> = any> = Omit<SaveEntityProps<M>, "collection">;
+
+export type FetchCollectionDelegateProps<M extends Record<string, any> = any> =
+    Omit<FetchCollectionProps<M>, "collection">
+    & {
+    isCollectionGroup?: boolean
+};
+
+export type ListenCollectionDelegateProps<M extends Record<string, any> = any> =
+    Omit<ListenCollectionProps<M>, "collection">
+    & {
+    isCollectionGroup?: boolean
+};
+
+export interface DataSourceDelegate {
+    /**
+     * Fetch data from a collection
+     * @param path
+     * @param filter
+     * @param limit
+     * @param startAfter
+     * @param orderBy
+     * @param order
+     * @param searchString
+     * @return Function to cancel subscription
+     * @see useCollectionFetch if you need this functionality implemented as a hook
+     */
+    fetchCollection<M extends Record<string, any> = any>({
+                                                             path,
+                                                             filter,
+                                                             limit,
+                                                             startAfter,
+                                                             orderBy,
+                                                             order,
+                                                             searchString
+                                                         }: FetchCollectionDelegateProps<M>): Promise<Entity<M>[]>;
+
+    /**
+     * Listen to a collection in a given path. If you don't implement this method
+     * `fetchCollection` will be used instead, with no real time updates.
+     * @param path
+     * @param onUpdate
+     * @param onError
+     * @param filter
+     * @param limit
+     * @param startAfter
+     * @param orderBy
+     * @param order
+     * @param searchString
+     * @return Function to cancel subscription
+     * @see useCollectionFetch if you need this functionality implemented as a hook
+     */
+    listenCollection?<M extends Record<string, any> = any>({
+                                                               path,
+                                                               filter,
+                                                               limit,
+                                                               startAfter,
+                                                               searchString,
+                                                               orderBy,
+                                                               order,
+                                                               onUpdate,
+                                                               onError
+                                                           }: ListenCollectionDelegateProps<M>): () => void;
+
+    /**
+     * Retrieve an entity given a path and a collection
+     * @param path
+     * @param entityId
+     */
+    fetchEntity<M extends Record<string, any> = any>({
+                                                         path,
+                                                         entityId,
+                                                     }: Omit<FetchEntityProps<M>, "collection">): Promise<Entity<M> | undefined>;
+
+    /**
+     * Get realtime updates on one entity.
+     * @param path
+     * @param entityId
+     * @param collection
+     * @param onUpdate
+     * @param onError
+     * @return Function to cancel subscription
+     */
+    listenEntity?<M extends Record<string, any> = any>({
+                                                           path,
+                                                           entityId,
+                                                           onUpdate,
+                                                           onError
+                                                       }: Omit<ListenEntityProps<M>, "collection">): () => void;
+
+    /**
+     * Save entity to the specified path
+     * @param path
+     * @param id
+     * @param collection
+     * @param status
+     */
+    saveEntity<M extends Record<string, any> = any>({
+                                                        path,
+                                                        entityId,
+                                                        values,
+                                                        status
+                                                    }: SaveEntityDelegateProps<M>): Promise<Entity<M>>;
+
+    /**
+     * Delete an entity
+     * @param entity
+     * @return was the whole deletion flow successful
+     */
+    deleteEntity<M extends Record<string, any> = any>({ entity }: DeleteEntityProps<M>): Promise<void>;
+
+    /**
+     * Check if the given property is unique in the given collection
+     * @param path Collection path
+     * @param name of the property
+     * @param value
+     * @param entityId
+     * @return `true` if there are no other fields besides the given entity
+     */
+    checkUniqueField(path: string, name: string, value: any, entityId?: string): Promise<boolean>;
+
+    /**
+     * Generate an id for a new entity
+     */
+    generateEntityId(path: string): string;
+
+    /**
+     * Count the number of entities in a collection
+     */
+    countEntities<M extends Record<string, any> = any>(props: FetchCollectionDelegateProps<M>): Promise<number>;
+
+    /**
+     * Check if the given filter combination is valid
+     * @param props
+     */
+    isFilterCombinationValid?(props: Omit<FilterCombinationValidProps, "collection">): boolean;
+
+    /**
+     * Convert a FireCMS reference to a reference that can be used by the datasource
+     * @param reference
+     */
+    buildReference: (reference: EntityReference) => any,
+
+    /**
+     * Convert a FireCMS GeoPoint to a GeoPoint that can be used by the datasource
+     * @param geoPoint
+     */
+    buildGeoPoint: (geoPoint: GeoPoint) => any,
+
+    /**
+     * Get the object to generate the current time in the datasource
+     */
+    currentTime(): any;
+
+    buildDate: (date: Date) => any;
+
+    buildDeleteFieldValue: () => any;
+
+    delegateToCMSModel: (data: any) => any;
+
+    setDateToMidnight: (input?: any) => any;
 }

package/src/types/fields.tsx

@@ -8,7 +8,7 @@ import { ResolvedEntityCollection, ResolvedProperty } from "./resolved_entities"
  *
  * @category Form custom fields
  */
-export interface FieldProps<T extends CMSType = CMSType, CustomProps = any, M extends Record<string, any> = any> {
+export interface FieldProps<T extends CMSType = any, CustomProps = any, M extends Record<string, any> = any> {
 
     /**
      * Key of the property

package/src/types/firecms.tsx

@@ -5,7 +5,7 @@ import { DataSource } from "./datasource";
 import { EntityCollection, EntityCustomView } from "./collections";
 import { CMSView } from "./navigation";
 import { FireCMSContext } from "./firecms_context";
-import { FieldConfig } from "./field_config";
+import { PropertyConfig } from "./property_config";
 import { Locale } from "./locales";
 import { StorageSource } from "./storage";
 import { EntityLinkBuilder } from "./entity_link_builder";
@@ -84,9 +84,9 @@ export type FireCMSProps<UserType extends User> = {
     /**
      * Record of custom form fields to be used in the CMS.
      * You can use the key to reference the custom field in
-     * the `fieldConfig` prop of a property in a collection.
+     * the `propertyConfig` prop of a property in a collection.
      */
-    fields?: Record<string, FieldConfig>;
+    fields?: Record<string, PropertyConfig>;
 
     /**
      * List of additional custom views for entities.

package/src/types/firecms_context.tsx

@@ -11,7 +11,7 @@ import { UserConfigurationPersistence } from "./local_config_persistence";
 import { SideDialogsController } from "./side_dialogs_controller";
 import { FireCMSPlugin } from "./plugins";
 import { CMSAnalyticsEvent } from "./analytics";
-import { FieldConfig } from "./field_config";
+import { PropertyConfig } from "./property_config";
 import { EntityCustomView } from "./collections";
 
 /**
@@ -96,9 +96,9 @@ export type FireCMSContext<UserType extends User = User, AuthControllerType exte
     /**
      * Record of custom form fields to be used in the CMS.
      * You can use the key to reference the custom field in
-     * the `fieldConfig` prop of a property in a collection.
+     * the `propertyConfig` prop of a property in a collection.
      */
-    fields: Record<string, FieldConfig>;
+    fields: Record<string, PropertyConfig>;
 
     /**
      * List of additional custom views for entities.

package/src/types/index.ts

@@ -10,7 +10,7 @@ export * from "./user";
 export * from "./colors";
 export * from "./storage";
 export * from "./fields";
-export * from "./field_config";
+export * from "./property_config";
 export * from "./datasource";
 export * from "./entity_link_builder";
 export * from "./side_entity_controller";

package/src/types/properties.ts

@@ -85,7 +85,7 @@ export interface BaseProperty<T extends CMSType, CustomProps = any> {
      * All the configuration will be taken from the inherited config, and
      * overwritten by the current property config.
      */
-    fieldConfig?: string;
+    propertyConfig?: string;
 
     /**
      * Longer description of a field, displayed under a popover

package/src/types/{field_config.tsx → property_config.tsx}

@@ -2,15 +2,14 @@ import React from "react";
 import { CMSType, PropertyOrBuilder } from "./properties";
 
 /**
- * This is the configuration object for the field component generated for a
- * property.
+ * 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 FieldConfig<T extends CMSType = any> = {
+export type PropertyConfig<T extends CMSType = any> = {
 
     /**
-     * Key used to identify this field type.
+     * Key used to identify this property config.
      */
     key: string,