Merge recent fixes and features (#14)

Author: eveffer

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@inspatial/cloud",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "license": "Apache-2.0",
   "exports": {
     ".": "./mod.ts",

extensions/flutter/actions/generate-models.ts

@@ -112,6 +112,35 @@ function generateFlutterModel(
   lines.push(...constructorClass);
   lines.push("}");
 
+  if (type === "Entry") {
+    const listModelLines = generateListModel(entryOrChildType as EntryType);
+    lines.push(...listModelLines);
+  }
+  return lines;
+}
+
+function generateListModel(entryType: EntryType): Array<string> {
+  const listFields = new Map();
+  entryType.defaultListFields.forEach((fieldKey) => {
+    listFields.set(fieldKey, entryType.fields.get(fieldKey));
+  });
+  const listType = {
+    ...entryType,
+    name: entryType.name + "List",
+    fields: listFields,
+    children: undefined,
+  } as EntryType;
+  const className = convertString(listType.name, "pascal", true);
+  const lines: string[] = [
+    `final class ${className} extends Entry {`,
+  ];
+  const fields = generateFieldDefs(listType.fields);
+  lines.push(...fields);
+  const converting = generateJsonConverting(listType, "Entry");
+  lines.push(...converting);
+  const constructorClass = generateConstructor(listType, "Entry");
+  lines.push(...constructorClass);
+  lines.push("}");
   return lines;
 }
 function shouldIgnoreField(field: InField) {

src/orm/child-entry/child-entry.ts

@@ -225,7 +225,7 @@ export class ChildEntryList<T extends Record<string, unknown> = any> {
     }
 
     await this.deleteStaleRecords();
-    this.load(this._parentId);
+    await this.load(this._parentId);
   }
   async #refreshFetchedFields(child: ChildEntry): Promise<void> {
     for (const field of this._fields.values()) {

src/orm/db/db-types.ts

@@ -124,9 +124,11 @@ export interface ListOptions<T extends EntryBase = EntryBase> {
   order?: "asc" | "desc";
 }
 
-export type DBFilter = Array<
-  InFilter
->;
+export type DBFilter =
+  | Array<
+    InFilter
+  >
+  | Record<string, string | number | null | boolean>;
 
 export interface DBListOptions {
   columns?:

src/orm/db/filters.ts

@@ -1,9 +1,27 @@
-import type { DBFilter, FilterAll } from "#/orm/db/db-types.ts";
+import type { DBFilter, FilterAll, InFilter } from "#/orm/db/db-types.ts";
 import { raiseORMException } from "#/orm/orm-exception.ts";
 import { formatColumnName, formatDbValue } from "#/orm/db/utils.ts";
 
-export function makeFilterQuery(filters: DBFilter): Array<string> {
+export function makeFilterQuery(dbFilter: DBFilter): Array<string> {
   const filterQ: Array<string> = [];
+  const filters: Array<InFilter> = [];
+  if (Array.isArray(dbFilter)) {
+    filters.push(...dbFilter);
+  } else if (typeof dbFilter === "object") {
+    Object.entries(dbFilter).map(([key, value]) => {
+      if (value === null) {
+        return {
+          field: key,
+          op: "isEmpty",
+        };
+      }
+      return {
+        field: key,
+        op: "=",
+        value,
+      };
+    }) as Array<InFilter>;
+  }
   for (const filter of filters) {
     let filterString = "";
     const strings: Array<string> = [];

src/orm/entry/entry-type.ts

@@ -24,7 +24,7 @@ export class EntryType<
   FK extends PropertyKey = ExtractFieldKeys<E>,
 > extends BaseType<N> {
   config: EntryTypeConfig;
-  defaultListFields: Set<string> = new Set(["id", "createdAt", "updatedAt"]);
+  defaultListFields: Set<string> = new Set(["id"]);
   defaultSortField?: FK;
   defaultSortDirection?: "asc" | "desc" = "asc";
   actions: Map<string, EntryActionDefinition> = new Map();
@@ -40,7 +40,7 @@ export class EntryType<
   };
   constructor(
     name: N,
-    config: BaseConfig & {
+    config: BaseConfig<FK> & {
       /**
        * The field to use as the display value instead of the ID.
        */
@@ -57,8 +57,8 @@ export class EntryType<
     },
   ) {
     super(name, config);
-    this.defaultSortField = config.defaultSortField;
-    this.defaultSortDirection = config.defaultSortDirection;
+    this.defaultSortField = config.defaultSortField || "id" as FK;
+    this.defaultSortDirection = config.defaultSortDirection || "asc";
     this.fields.set("id", {
       key: "id",
       type: "IDField",
@@ -112,6 +112,8 @@ export class EntryType<
         this.defaultListFields.add(fieldKey);
       }
     }
+    this.defaultListFields.add("updatedAt");
+    this.defaultListFields.add("createdAt");
     if (this.config.titleField) {
       this.defaultListFields.add(this.config.titleField);
     }

src/orm/inspatial-orm.ts

@@ -35,6 +35,7 @@ import { inLog } from "#/in-log/in-log.ts";
 import { ConnectionRegistry } from "#/orm/registry/connection-registry.ts";
 import type { InValue } from "#/orm/field/types.ts";
 import { registerFetchFields } from "#/orm/setup/setup-utils.ts";
+import { IDValue } from "./entry/types.ts";
 
 export class InSpatialORM {
   db: InSpatialDB;
@@ -287,7 +288,7 @@ export class InSpatialORM {
    */
   async getEntry<E extends EntryBase = GenericEntry>(
     entryType: string,
-    id: string,
+    id: IDValue,
     user?: SessionData,
   ): Promise<E> {
     const entry = this.#getEntryInstance(entryType, user) as E;

src/orm/migrate/entry-type/entry-type-migrator.ts

@@ -160,7 +160,6 @@ export class EntryTypeMigrator<T extends EntryType | ChildEntryType>
           continue;
       }
       const titleField = this.entryType.connectionTitleFields.get(field.key);
-
       if (titleField) {
         const ormTitleField = this.orm._getFieldType(titleField.type);
         const dbTitleColumn = ormTitleField.generateDbColumn(titleField);
@@ -209,12 +208,12 @@ export class EntryTypeMigrator<T extends EntryType | ChildEntryType>
   }
   async #checkTableInfo(): Promise<void> {
     const tableExists = await this.db.tableExists(this.#tableName);
-    const newDescription = this.entryType.config.description;
+    const newDescription = this.entryType.config.description || null;
     if (!tableExists) {
       this.migrationPlan.table.create = true;
       this.migrationPlan.table.updateDescription = {
         from: "",
-        to: newDescription,
+        to: newDescription ?? "",
       };
       return;
     }
@@ -223,7 +222,7 @@ export class EntryTypeMigrator<T extends EntryType | ChildEntryType>
     if (existingDescription != newDescription) {
       this.migrationPlan.table.updateDescription = {
         from: existingDescription,
-        to: newDescription,
+        to: newDescription ?? "",
       };
     }
   }

src/orm/setup/setup-utils.ts

@@ -137,7 +137,7 @@ function buildConnectionTitleField(
   connectionEntryType: EntryType,
 ): InField | undefined {
   const titleFieldKey = connectionEntryType.config.titleField;
-  if (!titleFieldKey) {
+  if (!titleFieldKey || titleFieldKey === "id") {
     return;
   }
 

src/orm/shared/base-type-class.ts

@@ -1,19 +1,21 @@
 import { raiseORMException } from "#/orm/orm-exception.ts";
 import convertString from "#/utils/convert-string.ts";
 import type { ChildEntryType } from "#/orm/child-entry/child-entry.ts";
-import type { BaseTypeInfo } from "#/orm/shared/shared-types.ts";
+import type {
+  BaseTypeInfo,
+  FieldGroup,
+  FieldGroupConfig,
+} from "#/orm/shared/shared-types.ts";
 import type { InField } from "#/orm/field/field-def-types.ts";
 
 export class BaseType<N extends string = string> {
   name: N;
   label: string;
 
   description: string;
-  /**
-   * The fields of the settings type.
-   */
   fields: Map<string, InField> = new Map();
   displayFields: Map<string, InField> = new Map();
+  fieldGroups: Map<string, FieldGroup> = new Map();
   connectionTitleFields: Map<string, InField> = new Map();
   children?: Map<string, ChildEntryType<any>>;
   #baseInfo: BaseTypeInfo;
@@ -22,6 +24,7 @@ export class BaseType<N extends string = string> {
     name: N,
     config: {
       fields: Array<InField>;
+      fieldGroups?: Array<FieldGroupConfig>;
       label?: string;
       description?: string;
       children?: Array<ChildEntryType<any>>;
@@ -52,13 +55,15 @@ export class BaseType<N extends string = string> {
     }
 
     this.#setDisplayFields();
+    this.#addFieldGroups(config.fieldGroups);
     this.#baseInfo = {
       name: this.name,
       label: this.label,
       description: this.description,
       fields: Array.from(this.fields.values()),
       titleFields: Array.from(this.connectionTitleFields.values()),
       displayFields: Array.from(this.displayFields.values()),
+      fieldGroups: Array.from(this.fieldGroups.values()),
     };
     this.#addChildren(config.children);
   }
@@ -97,6 +102,50 @@ export class BaseType<N extends string = string> {
     );
   }
 
+  #addFieldGroups(fieldGroups?: Array<FieldGroupConfig>): void {
+    const allFields = new Set(Array.from(this.fields.keys()));
+    for (const group of fieldGroups || []) {
+      this.#addFieldGroup(group, allFields);
+    }
+    if (allFields.size > 0) {
+      const defaultGroup: FieldGroupConfig = {
+        key: "default",
+        label: "",
+        fields: Array.from(allFields),
+      };
+      this.#addFieldGroup(defaultGroup, allFields);
+    }
+  }
+  #addFieldGroup(fieldGroupConfig: FieldGroupConfig, allFields: Set<string>) {
+    const fieldGroup: FieldGroup = {
+      ...fieldGroupConfig,
+      label: fieldGroupConfig.label === undefined
+        ? convertString(fieldGroupConfig.key, "title", true)
+        : fieldGroupConfig.label,
+      fields: [],
+      displayFields: [],
+    };
+    if (this.fieldGroups.has(fieldGroupConfig.key)) {
+      raiseORMException(
+        `Field group ${fieldGroupConfig.key} already exists in ${this.name}`,
+      );
+    }
+    for (const fieldKey of fieldGroupConfig.fields) {
+      const field = this.fields.get(fieldKey as string);
+      if (!field) {
+        raiseORMException(
+          `field ${fieldKey as string} does not exists in ${this.name}`,
+        );
+      }
+      allFields.delete(field.key);
+      fieldGroup.fields.push(field);
+      const displayField = this.displayFields.get(field.key);
+      if (displayField) {
+        fieldGroup.displayFields.push(displayField);
+      }
+    }
+    this.fieldGroups.set(fieldGroup.key, fieldGroup);
+  }
   set info(info: Record<string, any>) {
     this.#info = info;
   }