8.x - Multiple terminologies support

package.json

@@ -22,7 +22,7 @@
     },
     "dependencies": {
         "@ai-sdk/svelte": "^1.1.24",
-        "@appwrite.io/console": "https://pkg.vc/-/@appwrite/@appwrite.io/console@9c55755",
+        "@appwrite.io/console": "https://pkg.vc/-/@appwrite/@appwrite.io/console@e621876",
         "@appwrite.io/pink-icons": "0.25.0",
         "@appwrite.io/pink-icons-svelte": "https://pkg.vc/-/@appwrite/@appwrite.io/pink-icons-svelte@bbad65f",
         "@appwrite.io/pink-legacy": "^1.0.3",

src/lib/actions/analytics.ts

@@ -52,7 +52,7 @@ const analytics = Analytics({
 });
 
 export function trackEvent(name: string, data: object = null): void {
-    if (!isTrackingAllowed()) {
+    if (!name || !isTrackingAllowed()) {
         return;
     }
 
@@ -76,7 +76,7 @@ export function trackEvent(name: string, data: object = null): void {
 }
 
 export function trackError(exception: Error, event: Submit): void {
-    if (exception instanceof AppwriteException && exception.type) {
+    if (exception instanceof AppwriteException && exception.type && event) {
         trackEvent(Submit.Error, {
             type: exception.type,
             form: event
@@ -148,11 +148,14 @@ export enum Click {
     ConnectRepositoryClick = 'click_connect_repository',
     CreditsRedeemClick = 'click_credits_redeem',
     CloudSignupClick = 'click_cloud_signup',
+
     DatabaseColumnDelete = 'click_column_delete',
     DatabaseIndexDelete = 'click_index_delete',
     DatabaseTableDelete = 'click_table_delete',
+    DatabaseRowDelete = 'click_row_delete',
     DatabaseDatabaseDelete = 'click_database_delete',
     DatabaseImportCsv = 'click_database_import_csv',
+
     DomainCreateClick = 'click_domain_create',
     DomainDeleteClick = 'click_domain_delete',
     DomainRetryDomainVerificationClick = 'click_domain_retry_domain_verification',
@@ -279,6 +282,7 @@ export enum Submit {
     DatabaseUpdateName = 'submit_database_update_name',
     DatabaseImportCsv = 'submit_database_import_csv',
     DatabaseBackupDelete = 'submit_database_backup_delete',
+    DatabaseBackupPolicyCreate = 'submit_database_backup_policy_create',
 
     ColumnCreate = 'submit_column_create',
     ColumnUpdate = 'submit_column_update',
@@ -289,15 +293,18 @@ export enum Submit {
     RowDelete = 'submit_row_delete',
     RowUpdate = 'submit_row_update',
     RowUpdatePermissions = 'submit_row_update_permissions',
+
     IndexCreate = 'submit_index_create',
     IndexDelete = 'submit_index_delete',
-    TableCreate = 'submit_row_create',
-    TableDelete = 'submit_row_delete',
-    TableUpdateName = 'submit_row_update_name',
-    TableUpdatePermissions = 'submit_row_update_permissions',
-    TableUpdateSecurity = 'submit_row_update_security',
-    TableUpdateEnabled = 'submit_row_update_enabled',
-    TableUpdateDisplayNames = 'submit_row_update_display_names',
+
+    TableCreate = 'submit_table_create',
+    TableDelete = 'submit_table_delete',
+    TableUpdateName = 'submit_table_update_name',
+    TableUpdatePermissions = 'submit_table_update_permissions',
+    TableUpdateSecurity = 'submit_table_update_security',
+    TableUpdateEnabled = 'submit_table_update_enabled',
+    TableUpdateDisplayNames = 'submit_table_update_display_names',
+
     FunctionCreate = 'submit_function_create',
     FunctionDelete = 'submit_function_delete',
     FunctionUpdateName = 'submit_function_update_name',

src/lib/components/backupRestoreBox.svelte

@@ -57,21 +57,22 @@
     }
 
     function updateOrAddItem(payload: Payload) {
-        // todo: @itznotabug - might need a change to $table?
-        const { $id, status, $collection, policyId } = payload;
-        if ($collection === 'archives' && policyId !== null) {
+        // the internal structure still uses `$collection`,
+        // and is basically an identifier of the op. type here!
+        const { $id, status, $collection: type, policyId } = payload;
+        if (type === 'archives' && policyId !== null) {
             return;
         }
 
-        if ($collection in backupRestoreItems) {
-            const collectionMap = backupRestoreItems[$collection];
+        if (type in backupRestoreItems) {
+            const collectionMap = backupRestoreItems[type];
 
             if (collectionMap.has($id)) {
                 collectionMap.get($id).status = status;
                 if (status === 'completed') {
                     invalidate(Dependencies.BACKUPS);
 
-                    if ($collection === 'restorations') {
+                    if (type === 'restorations') {
                         const { newId, newName } =
                             collectionMap.get($id).options?.['databases']?.['database'][0] || {};
 
@@ -81,7 +82,7 @@
             } else if (status === 'pending' || status === 'processing' || status === 'uploading') {
                 collectionMap.set($id, payload);
             }
-            backupRestoreItems[$collection] = collectionMap;
+            backupRestoreItems[type] = collectionMap;
         }
     }
 

src/lib/helpers/faker.ts

@@ -1,79 +1,96 @@
+import { sdk } from '$lib/stores/sdk';
 import { faker } from '@faker-js/faker';
-import type { Columns } from '$routes/(console)/project-[region]-[project]/databases/database-[database]/table-[table]/store';
+import type { NestedNumberArray } from './types';
 import { ID, type Models } from '@appwrite.io/console';
-import { sdk } from '$lib/stores/sdk';
 import { isWithinSafeRange } from '$lib/helpers/numbers';
-import type { NestedNumberArray } from './types';
+import type { DatabaseType, Field } from '$database/(entity)';
 
-export async function generateColumns(
+export async function generateFields(
     project: Models.Project,
     databaseId: string,
-    tableId: string
-): Promise<Columns[]> {
+    tableId: string,
+    databaseType: DatabaseType
+): Promise<Field[]> {
     const client = sdk.forProject(project.region, project.$id);
 
-    return await Promise.all([
-        client.tablesDB.createStringColumn({
-            databaseId,
-            tableId,
-            key: 'name',
-            size: 255,
-            required: false
-        }),
-        client.tablesDB.createEmailColumn({ databaseId, tableId, key: 'email', required: false }),
-        client.tablesDB.createIntegerColumn({
-            databaseId,
-            tableId,
-            key: 'age',
-            required: false,
-            min: 18,
-            max: 80
-        }),
-        client.tablesDB.createStringColumn({
-            databaseId,
-            tableId,
-            key: 'city',
-            size: 100,
-            required: false
-        }),
-        client.tablesDB.createStringColumn({
-            databaseId,
-            tableId,
-            key: 'description',
-            size: 1000,
-            required: false
-        }),
-        client.tablesDB.createBooleanColumn({
-            databaseId,
-            tableId,
-            key: 'active',
-            required: false
-        }),
-        client.tablesDB.createPointColumn({
-            databaseId,
-            tableId,
-            key: 'location',
-            required: false
-        }),
-        client.tablesDB.createLineColumn({
-            databaseId,
-            tableId,
-            key: 'route',
-            required: false
-        })
-    ]);
+    switch (databaseType) {
+        case 'legacy':
+        case 'tablesdb': {
+            return await Promise.all([
+                client.tablesDB.createStringColumn({
+                    databaseId,
+                    tableId,
+                    key: 'name',
+                    size: 255,
+                    required: false
+                }),
+                client.tablesDB.createEmailColumn({
+                    databaseId,
+                    tableId,
+                    key: 'email',
+                    required: false
+                }),
+                client.tablesDB.createIntegerColumn({
+                    databaseId,
+                    tableId,
+                    key: 'age',
+                    required: false,
+                    min: 18,
+                    max: 80
+                }),
+                client.tablesDB.createStringColumn({
+                    databaseId,
+                    tableId,
+                    key: 'city',
+                    size: 100,
+                    required: false
+                }),
+                client.tablesDB.createStringColumn({
+                    databaseId,
+                    tableId,
+                    key: 'description',
+                    size: 1000,
+                    required: false
+                }),
+                client.tablesDB.createBooleanColumn({
+                    databaseId,
+                    tableId,
+                    key: 'active',
+                    required: false
+                }),
+                client.tablesDB.createPointColumn({
+                    databaseId,
+                    tableId,
+                    key: 'location',
+                    required: false
+                }),
+                client.tablesDB.createLineColumn({
+                    databaseId,
+                    tableId,
+                    key: 'route',
+                    required: false
+                })
+            ]);
+        }
+
+        case 'documentsdb': /* doesn't need any fields */
+        case 'vectordb': /* vector embeddings + metadata defined at collection creation */ {
+            /* no individual field creation needed */
+            return [];
+        }
+    }
 }
 
 export function generateFakeRecords(
-    columns: Columns[],
+    fields: Field[],
     count: number
 ): {
     ids: string[];
     rows: Models.Row[];
 } {
     if (count <= 0) return { ids: [], rows: [] };
 
-    const filteredColumns = columns.filter(
+    const filteredColumns = fields.filter(
         (col) => col.type !== 'relationship' && col.status === 'available'
     );
 
@@ -108,7 +125,7 @@ export function generateFakeRecords(
             };
         } else {
             for (const column of filteredColumns) {
-                row[column.key] = generateValueForColumn(column);
+                row[column.key] = generateValueForField(column);
             }
         }
 
@@ -140,15 +157,15 @@ function generateStringValue(key: string, maxLength: number): string {
     return text.length <= maxLength ? text : text.substring(0, maxLength);
 }
 
-function generateValueForColumn(
-    column: Columns
+function generateValueForField(
+    field: Field
 ): string | number | boolean | null | Array<string | number | boolean | NestedNumberArray> {
-    if (column.array) {
+    if (field.array) {
         const arraySize = faker.number.int({ min: 1, max: 5 });
         const items: Array<string | number | NestedNumberArray | boolean> = [];
 
         for (let i = 0; i < arraySize; i++) {
-            const itemAttribute = { ...column, array: false };
+            const itemAttribute = { ...field, array: false };
             const item = generateSingleValue(itemAttribute);
             if (item !== null) {
                 items.push(item);
@@ -158,16 +175,14 @@ function generateValueForColumn(
         return items;
     }
 
-    return generateSingleValue(column);
+    return generateSingleValue(field);
 }
 
-function generateSingleValue(
-    column: Columns
-): string | number | boolean | NestedNumberArray | null {
-    switch (column.type) {
+function generateSingleValue(field: Field): string | number | boolean | NestedNumberArray | null {
+    switch (field.type) {
         case 'string': {
-            if ('format' in column && column.format) {
-                switch (column.format) {
+            if ('format' in field && field.format) {
+                switch (field.format) {
                     case 'email': {
                         return faker.internet.email();
                     }
@@ -181,7 +196,7 @@ function generateSingleValue(
                     }
 
                     case 'enum': {
-                        const enumAttr = column as Models.ColumnEnum;
+                        const enumAttr = field as Models.ColumnEnum;
                         if (enumAttr.elements?.length > 0) {
                             return faker.helpers.arrayElement(enumAttr.elements);
                         }
@@ -190,14 +205,14 @@ function generateSingleValue(
                 }
                 return '';
             } else {
-                const stringAttr = column as Models.ColumnString;
+                const stringAttr = field as Models.ColumnString;
                 const maxLength = Math.min(stringAttr.size ?? 255, 1000);
-                return generateStringValue(column.key, maxLength);
+                return generateStringValue(field.key, maxLength);
             }
         }
 
         case 'integer': {
-            const intAttr = column as Models.ColumnInteger;
+            const intAttr = field as Models.ColumnInteger;
             const min = isWithinSafeRange(intAttr.min) ? intAttr.min : 0;
             const fallbackMax = Math.max(min + 100, 100);
             const max = isWithinSafeRange(intAttr.max)
@@ -207,7 +222,7 @@ function generateSingleValue(
         }
 
         case 'double': {
-            const floatAttr = column as Models.ColumnFloat;
+            const floatAttr = field as Models.ColumnFloat;
             const min = isWithinSafeRange(floatAttr.min) ? floatAttr.min : 0;
             const fallbackMax = Math.max(min + 100, 100);
             const max = isWithinSafeRange(floatAttr.max)