Feat: multi-terminology support

src/lib/actions/analytics.ts

@@ -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',
@@ -265,7 +268,7 @@ export enum Submit {
     AuthSessionAlertsUpdate = 'submit_auth_session_alerts_update',
     AuthMembershipPrivacyUpdate = 'submit_auth_membership_privacy_update',
     AuthMockNumbersUpdate = 'submit_auth_mock_numbers_update',
-    AuthInvalidateSesssion = 'submit_auth_invalidate_session',
+    AuthInvalidateSession = 'submit_auth_invalidate_session',
     SessionsLengthUpdate = 'submit_sessions_length_update',
     SessionsLimitUpdate = 'submit_sessions_limit_update',
     SessionDelete = 'submit_session_delete',
@@ -284,15 +287,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/string.ts

@@ -21,6 +21,43 @@ export function singular(str: string): string {
     return str.replace(/s$/, '');
 }
 
+/**
+ * Given a string, returns the plural version of it.
+ *
+ * Handles common English pluralization rules:
+ * - Words ending in consonant + y → ies
+ * - Words ending in vowel + y → s
+ * - Words ending in sibilants (s, sh, ch, x, z) → es
+ * - Regular words → s
+ *
+ * @export
+ * @param {string} str
+ * @returns {string}
+ */
+export function plural(str: string): string {
+    if (!str) return str;
+
+    const lower = str.toLowerCase();
+
+    // Words ending in sibilants: s, sh, ch, x, z
+    if (/[sxz]$/.test(lower) || /[cs]h$/.test(lower)) {
+        return str + 'es';
+    }
+
+    // Words ending in consonant + y → ies
+    // Words ending in vowel + y → s
+    if (str.endsWith('y')) {
+        const beforeY = str.slice(-2, -1).toLowerCase();
+        if (beforeY && !['a', 'e', 'i', 'o', 'u'].includes(beforeY)) {
+            return str.slice(0, -1) + 'ies';
+        }
+        return str + 's';
+    }
+
+    // Default: add 's'
+    return str + 's';
+}
+
 /**
  * Convert a dash/underscore/space separated string to camelCase.
  *

src/lib/stores/navigation.ts

@@ -0,0 +1,29 @@
+import { resolve } from '$app/paths';
+import { goto } from '$app/navigation';
+import type { Pathname, RouteId, RouteParams } from '$app/types';
+
+// taken directly from svelte's source!
+type ResolveArgs<T extends RouteId | Pathname> = T extends RouteId
+    ? RouteParams<T> extends Record<string, never>
+        ? [route: T]
+        : [route: T, params: RouteParams<T>]
+    : [route: T];
+
+export function withPath(base: string, ...parts: string[]) {
+    return [base.replace(/\/+$/, ''), ...parts].join('/');
+}
+
+export function resolveRoute<T extends RouteId>(route: T, params?: Record<string, string>) {
+    // type cast is necessary here!
+    const resolveArgs = params ? ([route, params] as [T, RouteParams<T>]) : [route];
+
+    return resolve(...(resolveArgs as ResolveArgs<T>));
+}
+
+export function navigate<T extends RouteId>(
+    route: T,
+    params?: Record<string, string>
+): Promise<void> {
+    // type cast is necessary here!
+    return goto(resolveRoute(route, params));
+}

src/lib/stores/sdk.ts

@@ -21,7 +21,8 @@ import {
     Sites,
     Tokens,
     TablesDB,
-    Domains
+    Domains,
+    Databases // DocumentsDB later
 } from '@appwrite.io/console';
 import { Billing } from '../sdk/billing';
 import { Backups } from '../sdk/backups';
@@ -131,6 +132,7 @@ const sdkForProject = {
     migrations: new Migrations(clientProject),
     sites: new Sites(clientProject),
     tablesDB: new TablesDB(clientProject),
+    documentsDB: new Databases(clientProject), // documentsDB later
     console: new Console(clientProject) // for suggestions API
 };
 

src/routes/(console)/project-[region]-[project]/auth/security/updateSessionInvalidation.svelte

@@ -22,13 +22,13 @@
                 type: 'success',
                 message: 'Updated session invalidation check.'
             });
-            trackEvent(Submit.AuthInvalidateSesssion);
+            trackEvent(Submit.AuthInvalidateSession);
         } catch (error) {
             addNotification({
                 type: 'error',
                 message: error.message
             });
-            trackError(error, Submit.AuthInvalidateSesssion);
+            trackError(error, Submit.AuthInvalidateSession);
         }
     }
 </script>

src/routes/(console)/project-[region]-[project]/databases/database-[database]/(entity)/helpers/analytics.ts

@@ -0,0 +1,51 @@
+import type { Page } from '@sveltejs/kit';
+import { page as pageState } from '$app/state';
+
+import { useTerminology } from './terminology';
+import { Submit, Click } from '$lib/actions/analytics';
+import type { AnalyticsResult, TerminologyResult, TerminologyShape } from './types';
+
+export function useAnalytics(pageOrTerms: Page | TerminologyResult = pageState): AnalyticsResult {
+    const terminology = 'source' in pageOrTerms ? pageOrTerms : useTerminology(pageOrTerms);
+
+    const createSubmitHandler = <TAction extends string>(termType: keyof TerminologyShape) => {
+        return (action: TAction) => {
+            const term = terminology.source[termType];
+            if (!term) {
+                throw new Error(`No ${termType} terminology found`);
+            }
+            const enumKey = `${term.title.singular}${action}`;
+            return Submit[enumKey as keyof typeof Submit];
+        };
+    };
+
+    const createClickHandler = <TAction extends string>(termType: keyof TerminologyShape) => {
+        return (action: TAction) => {
+            const term = terminology.source[termType];
+            if (!term) {
+                throw new Error(`No ${termType} terminology found`);
+            }
+            const enumKey = `Database${term.title.singular}${action}`;
+            return Click[enumKey as keyof typeof Click];
+        };
+    };
+
+    const result: AnalyticsResult = { submit: {}, click: {} };
+
+    if (terminology.entity) {
+        result.click.entity = createClickHandler('entity');
+        result.submit.entity = createSubmitHandler('entity');
+    }
+
+    if (terminology.field) {
+        result.click.field = createClickHandler('field');
+        result.submit.field = createSubmitHandler('field');
+    }
+
+    if (terminology.record) {
+        result.click.record = createClickHandler('record');
+        result.submit.record = createSubmitHandler('record');
+    }
+
+    return result;
+}

src/routes/(console)/project-[region]-[project]/databases/database-[database]/(entity)/helpers/dependencies.ts

@@ -0,0 +1,24 @@
+import type { Page } from '@sveltejs/kit';
+import { page as pageState } from '$app/state';
+
+import { useTerminology } from './terminology';
+import { Dependencies } from '$lib/constants';
+import type { DependenciesResult, Term, TerminologyResult } from './types';
+
+export function useDependencies(
+    pageOrTerms: Page | TerminologyResult = pageState
+): DependenciesResult {
+    // source is in `TerminologyResult`.
+    const terminology = 'source' in pageOrTerms ? pageOrTerms : useTerminology(pageOrTerms);
+
+    const getDependencies = (term: { title: Term }) => ({
+        singular: Dependencies[term.title.singular.toUpperCase() as keyof typeof Dependencies],
+        plural: Dependencies[term.title.plural.toUpperCase() as keyof typeof Dependencies]
+    });
+
+    return {
+        entity: terminology.entity ? getDependencies(terminology.entity) : undefined,
+        field: terminology.field ? getDependencies(terminology.field) : undefined,
+        record: terminology.record ? getDependencies(terminology.record) : undefined
+    };
+}

src/routes/(console)/project-[region]-[project]/databases/database-[database]/(entity)/helpers/index.ts

@@ -0,0 +1,5 @@
+export * from './init';
+export * from './types';
+export * from './analytics';
+export * from './terminology';
+export * from './dependencies';

src/routes/(console)/project-[region]-[project]/databases/database-[database]/(entity)/helpers/init.ts

@@ -0,0 +1,35 @@
+import type { Page } from '@sveltejs/kit';
+import { getContext, setContext } from 'svelte';
+import {
+    type AnalyticsResult,
+    type DependenciesResult,
+    type TerminologyResult,
+    useAnalytics,
+    useDependencies,
+    useTerminology
+} from '$database/(entity)';
+
+const TERMINOLOGIES_KEY = Symbol('terminologies');
+
+export type Terminologies = {
+    analytics: AnalyticsResult;
+    terminology: TerminologyResult;
+    dependencies: DependenciesResult;
+};
+
+export function getTerminologies(): Terminologies {
+    return getContext<Terminologies>(TERMINOLOGIES_KEY);
+}
+
+export function setTerminologies(page: Page) {
+    setContext(TERMINOLOGIES_KEY, buildTerminologies(page));
+}
+
+function buildTerminologies(page: Page) {
+    const terminology = useTerminology(page);
+    return {
+        terminology,
+        analytics: useAnalytics(terminology),
+        dependencies: useDependencies(terminology)
+    };
+}

src/routes/(console)/project-[region]-[project]/databases/database-[database]/(entity)/helpers/terminology.ts

@@ -0,0 +1,68 @@
+import type { Page } from '@sveltejs/kit';
+import { page as pageStage } from '$app/state';
+
+import { type Models } from '@appwrite.io/console';
+import { capitalize, plural } from '$lib/helpers/string';
+import type { Columns } from '$database/table-[table]/store';
+import type { Term, TerminologyResult, TerminologyShape } from '$database/(entity)/helpers/types';
+
+export type DatabaseType = 'legacy' | 'tablesdb' | 'documentsdb' | 'vectordb';
+export type Entity = Partial<Models.Table>;
+export type Field = Partial<Columns>;
+export type Index = Partial<Models.Index | Models.ColumnIndex>;
+
+export const baseTerminology = {
+    tablesdb: {
+        entity: 'table',
+        field: 'column',
+        record: 'row'
+    },
+    documentsdb: {
+        entity: 'collection',
+        record: 'document'
+    },
+    legacy: {
+        entity: 'collection',
+        field: 'attribute',
+        record: 'document'
+    },
+    vectordb: {}
+} as const;
+
+const createTerm = (singular: string, pluralForm: string): Term => {
+    return { singular, plural: pluralForm };
+};
+
+// transforms a base into lower/title variants
+const createTermVariants = (baseTerm: string) => ({
+    lower: createTerm(baseTerm, plural(baseTerm)),
+    title: createTerm(capitalize(baseTerm), plural(capitalize(baseTerm)))
+});
+
+// transforms terminology for a database type
+const transformDatabaseTerms = (terms: Partial<TerminologyShape>) =>
+    Object.fromEntries(
+        Object.entries(terms).map(([key, term]) => [
+            key,
+            term ? createTermVariants(term) : undefined
+        ])
+    );
+
+// build the terminology data
+const terminologyData = Object.fromEntries(
+    Object.entries(baseTerminology).map(([dbType, terms]) => [
+        dbType,
+        transformDatabaseTerms(terms)
+    ])
+);
+
+export function useTerminology(page: Page = pageStage): TerminologyResult {
+    const type = page.data?.database?.type as DatabaseType;
+    const dbTerminologies = terminologyData[type] || {};
+    return {
+        source: dbTerminologies,
+        field: dbTerminologies.field,
+        record: dbTerminologies.record,
+        entity: dbTerminologies.entity
+    };
+}