appwrite-cli 17.2.1 → 17.3.0

package/lib/commands/generators/typescript/templates/databases.ts.hbs

@@ -1,216 +0,0 @@
-import { Client, TablesDB, ID, Query, type Models, Permission, Role } from '{{appwriteDep}}';
-import type { DatabaseHandle, DatabaseId, DatabaseTableMap, DatabaseTables, QueryBuilder, QueryValue, PermissionBuilder, RoleBuilder, RoleString } from './types{{importExt}}';
-{{#if supportsServerSide}}
-import { PROJECT_ID, ENDPOINT, API_KEY } from './constants{{importExt}}';
-{{else}}
-import { PROJECT_ID, ENDPOINT } from './constants{{importExt}}';
-{{/if}}
-
-const createQueryBuilder = <T>(): QueryBuilder<T> => ({
-  equal: (field, value) => Query.equal(String(field), value as QueryValue),
-  notEqual: (field, value) => Query.notEqual(String(field), value as QueryValue),
-  lessThan: (field, value) => Query.lessThan(String(field), value as QueryValue),
-  lessThanEqual: (field, value) => Query.lessThanEqual(String(field), value as QueryValue),
-  greaterThan: (field, value) => Query.greaterThan(String(field), value as QueryValue),
-  greaterThanEqual: (field, value) => Query.greaterThanEqual(String(field), value as QueryValue),
-  contains: (field, value) => Query.contains(String(field), value as string | QueryValue[]),
-  search: (field, value) => Query.search(String(field), value),
-  isNull: (field) => Query.isNull(String(field)),
-  isNotNull: (field) => Query.isNotNull(String(field)),
-  startsWith: (field, value) => Query.startsWith(String(field), value),
-  endsWith: (field, value) => Query.endsWith(String(field), value),
-  between: (field, start, end) => Query.between(String(field), start as string | number, end as string | number),
-  select: (fields) => Query.select(fields.map(String)),
-  orderAsc: (field) => Query.orderAsc(String(field)),
-  orderDesc: (field) => Query.orderDesc(String(field)),
-  limit: (value) => Query.limit(value),
-  offset: (value) => Query.offset(value),
-  cursorAfter: (documentId) => Query.cursorAfter(documentId),
-  cursorBefore: (documentId) => Query.cursorBefore(documentId),
-  or: (...queries) => Query.or(queries),
-  and: (...queries) => Query.and(queries),
-});
-
-{{{TABLE_ID_MAP}}}
-
-{{{TABLES_WITH_RELATIONSHIPS}}}
-
-const roleBuilder: RoleBuilder = {
-  any: () => Role.any() as RoleString,
-  user: (userId, status?) => Role.user(userId, status) as RoleString,
-  users: (status?) => Role.users(status) as RoleString,
-  guests: () => Role.guests() as RoleString,
-  team: (teamId, role?) => Role.team(teamId, role) as RoleString,
-  member: (memberId) => Role.member(memberId) as RoleString,
-  label: (label) => Role.label(label) as RoleString,
-};
-
-const permissionBuilder: PermissionBuilder = {
-  read: (role) => Permission.read(role),
-  write: (role) => Permission.write(role),
-  create: (role) => Permission.create(role),
-  update: (role) => Permission.update(role),
-  delete: (role) => Permission.delete(role),
-};
-
-const resolvePermissions = (callback?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]): string[] | undefined =>
-  callback?.(permissionBuilder, roleBuilder);
-
-function createTableApi<T extends Models.Row>(
-  tablesDB: TablesDB,
-  databaseId: string,
-  tableId: string,
-) {
-  return {
-    create: (data: Omit<T, keyof Models.Row>, options?: { rowId?: string; permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; transactionId?: string }) =>
-      tablesDB.createRow<T>({
-        databaseId,
-        tableId,
-        rowId: options?.rowId ?? ID.unique(),
-        data: data as T extends Models.DefaultRow ? Partial<Models.Row> & Record<string, unknown> : Partial<Models.Row> & Omit<T, keyof Models.Row>,
-        permissions: resolvePermissions(options?.permissions),
-        transactionId: options?.transactionId,
-      }),
-    get: (id: string) =>
-      tablesDB.getRow<T>({
-        databaseId,
-        tableId,
-        rowId: id,
-      }),
-    update: (id: string, data: Partial<Omit<T, keyof Models.Row>>, options?: { permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; transactionId?: string }) =>
-      tablesDB.updateRow<T>({
-        databaseId,
-        tableId,
-        rowId: id,
-        data: data as T extends Models.DefaultRow ? Partial<Models.Row> & Record<string, unknown> : Partial<Models.Row> & Partial<Omit<T, keyof Models.Row>>,
-        ...(options?.permissions ? { permissions: resolvePermissions(options.permissions) } : {}),
-        transactionId: options?.transactionId,
-      }),
-    delete: async (id: string, options?: { transactionId?: string }) => {
-      await tablesDB.deleteRow({
-        databaseId,
-        tableId,
-        rowId: id,
-        transactionId: options?.transactionId,
-      });
-    },
-    list: (options?: { queries?: (q: QueryBuilder<T>) => string[] }) =>
-      tablesDB.listRows<T>({
-        databaseId,
-        tableId,
-        queries: options?.queries?.(createQueryBuilder<T>()),
-      }),{{{BULK_METHODS}}}
-  };
-}
-
-{{{BULK_CHECK}}}
-const hasOwn = (obj: unknown, key: string): boolean =>
-  obj != null && Object.prototype.hasOwnProperty.call(obj, key);
-
-function createDatabaseHandle<D extends DatabaseId>(
-  tablesDB: TablesDB,
-  databaseId: D,
-): DatabaseHandle<D> {
-  const tableApiCache = new Map<string, unknown>();
-  const dbMap = tableIdMap[databaseId];
-
-  return {
-    use: <T extends keyof DatabaseTableMap[D] & string>(tableId: T): DatabaseTableMap[D][T] => {
-      if (!hasOwn(dbMap, tableId)) {
-        throw new Error(`Unknown table "${tableId}" in database "${databaseId}"`);
-      }
-
-      if (!tableApiCache.has(tableId)) {
-        const resolvedTableId = dbMap[tableId];
-        const api = createTableApi(tablesDB, databaseId, resolvedTableId);
-        {{{BULK_REMOVAL}}}
-        tableApiCache.set(tableId, api);
-      }
-      return tableApiCache.get(tableId) as DatabaseTableMap[D][T];
-    },
-{{#if supportsServerSide}}
-    create: (tableId: string, name: string, options?: { permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; rowSecurity?: boolean; enabled?: boolean; columns?: object[]; indexes?: object[] }) =>
-      tablesDB.createTable({
-        databaseId,
-        tableId,
-        name,
-        permissions: resolvePermissions(options?.permissions),
-        rowSecurity: options?.rowSecurity,
-        enabled: options?.enabled,
-        columns: options?.columns,
-        indexes: options?.indexes,
-      }),
-    update: (tableId: string, options?: { name?: string; permissions?: (permission: { read: (role: RoleString) => string; write: (role: RoleString) => string; create: (role: RoleString) => string; update: (role: RoleString) => string; delete: (role: RoleString) => string }, role: { any: () => RoleString; user: (userId: string, status?: string) => RoleString; users: (status?: string) => RoleString; guests: () => RoleString; team: (teamId: string, role?: string) => RoleString; member: (memberId: string) => RoleString; label: (label: string) => RoleString }) => string[]; rowSecurity?: boolean; enabled?: boolean }) => {
-      if (!hasOwn(dbMap, tableId)) {
-        throw new Error(`Unknown table "${tableId}" in database "${databaseId}"`);
-      }
-      const resolvedTableId = dbMap[tableId];
-      return tablesDB.updateTable({
-        databaseId,
-        tableId: resolvedTableId,
-        name: options?.name,
-        permissions: resolvePermissions(options?.permissions),
-        rowSecurity: options?.rowSecurity,
-        enabled: options?.enabled,
-      });
-    },
-    delete: async (tableId: string) => {
-      if (!hasOwn(dbMap, tableId)) {
-        throw new Error(`Unknown table "${tableId}" in database "${databaseId}"`);
-      }
-      const resolvedTableId = dbMap[tableId];
-      await tablesDB.deleteTable({
-        databaseId,
-        tableId: resolvedTableId,
-      });
-    },
-{{/if}}
-  };
-}
-
-function createDatabasesApi(tablesDB: TablesDB): DatabaseTables {
-  const dbCache = new Map<DatabaseId, ReturnType<typeof createDatabaseHandle>>();
-
-  return {
-    use: (databaseId: DatabaseId) => {
-      if (!hasOwn(tableIdMap, databaseId)) {
-        throw new Error(`Unknown database "${databaseId}"`);
-      }
-
-      if (!dbCache.has(databaseId)) {
-        dbCache.set(databaseId, createDatabaseHandle(tablesDB, databaseId));
-      }
-      return dbCache.get(databaseId);
-    },
-{{#if supportsServerSide}}
-    create: (databaseId: string, name: string, options?: { enabled?: boolean }) =>
-      tablesDB.create({
-        databaseId,
-        name,
-        enabled: options?.enabled,
-      }),
-    update: (databaseId: DatabaseId, options?: { name?: string; enabled?: boolean }) => {
-      return tablesDB.update({
-        databaseId,
-        name: options?.name ?? databaseId,
-        enabled: options?.enabled,
-      });
-    },
-    delete: async (databaseId: DatabaseId) => {
-      await tablesDB.delete({
-        databaseId,
-      });
-    },
-{{/if}}
-  } as DatabaseTables;
-}
-
-// Initialize client
-const client = new Client()
-  .setEndpoint(ENDPOINT)
-  .setProject(PROJECT_ID){{#if supportsServerSide}}
-  .setKey(API_KEY){{/if}};
-
-const tablesDB = new TablesDB(client);
-
-export const databases: DatabaseTables = createDatabasesApi(tablesDB);

package/lib/commands/generators/typescript/templates/index.ts.hbs

@@ -1,9 +0,0 @@
-/**
- * {{sdkTitle}} Generated SDK
- *
- * This file is auto-generated. Do not edit manually.
- * Re-run `{{executableName}} generate` to regenerate.
- */
-
-export { databases } from "./databases{{importExt}}";
-export * from "./types{{importExt}}";

package/lib/commands/generators/typescript/templates/types.ts.hbs

@@ -1,64 +0,0 @@
-import { type Models } from '{{appwriteDep}}';
-
-{{{ENUMS}}}{{{TYPES}}}
-declare const __roleStringBrand: unique symbol;
-export type RoleString = string & { readonly [__roleStringBrand]: never };
-
-export type RoleBuilder = {
-  any: () => RoleString;
-  user: (userId: string, status?: string) => RoleString;
-  users: (status?: string) => RoleString;
-  guests: () => RoleString;
-  team: (teamId: string, role?: string) => RoleString;
-  member: (memberId: string) => RoleString;
-  label: (label: string) => RoleString;
-}
-
-export type PermissionBuilder = {
-  read: (role: RoleString) => string;
-  write: (role: RoleString) => string;
-  create: (role: RoleString) => string;
-  update: (role: RoleString) => string;
-  delete: (role: RoleString) => string;
-}
-
-export type PermissionCallback = (permission: PermissionBuilder, role: RoleBuilder) => string[];
-
-export type QueryValue = string | number | boolean;
-
-export type ExtractQueryValue<T> = T extends (infer U)[]
-  ? U extends QueryValue ? U : never
-  : T extends QueryValue | null ? NonNullable<T> : never;
-
-export type QueryableKeys<T> = {
-  [K in keyof T]: ExtractQueryValue<T[K]> extends never ? never : K;
-}[keyof T];
-
-export type QueryBuilder<T> = {
-  equal: <K extends QueryableKeys<T>>(field: K, value: ExtractQueryValue<T[K]>) => string;
-  notEqual: <K extends QueryableKeys<T>>(field: K, value: ExtractQueryValue<T[K]>) => string;
-  lessThan: <K extends QueryableKeys<T>>(field: K, value: ExtractQueryValue<T[K]>) => string;
-  lessThanEqual: <K extends QueryableKeys<T>>(field: K, value: ExtractQueryValue<T[K]>) => string;
-  greaterThan: <K extends QueryableKeys<T>>(field: K, value: ExtractQueryValue<T[K]>) => string;
-  greaterThanEqual: <K extends QueryableKeys<T>>(field: K, value: ExtractQueryValue<T[K]>) => string;
-  contains: <K extends QueryableKeys<T>>(field: K, value: ExtractQueryValue<T[K]>) => string;
-  search: <K extends QueryableKeys<T>>(field: K, value: string) => string;
-  isNull: <K extends QueryableKeys<T>>(field: K) => string;
-  isNotNull: <K extends QueryableKeys<T>>(field: K) => string;
-  startsWith: <K extends QueryableKeys<T>>(field: K, value: string) => string;
-  endsWith: <K extends QueryableKeys<T>>(field: K, value: string) => string;
-  between: <K extends QueryableKeys<T>>(field: K, start: ExtractQueryValue<T[K]>, end: ExtractQueryValue<T[K]>) => string;
-  select: <K extends keyof T>(fields: K[]) => string;
-  orderAsc: <K extends keyof T>(field: K) => string;
-  orderDesc: <K extends keyof T>(field: K) => string;
-  limit: (value: number) => string;
-  offset: (value: number) => string;
-  cursorAfter: (documentId: string) => string;
-  cursorBefore: (documentId: string) => string;
-  or: (...queries: string[]) => string;
-  and: (...queries: string[]) => string;
-}
-
-export type DatabaseId = {{{databaseIdType}}};
-
-{{{DATABASE_TABLES_TYPE}}}