appwrite-utils-cli 0.9.89 → 0.9.91

package/README.md

@@ -125,6 +125,8 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.9.91: Fixed another webpack error, screw you react (but you're supported now so I guess not-screw-you)
+- 0.9.90: Fixed Webpack errors (why tf does webpack add an extra `default`...???)
 - 0.9.80: Fixed collections not being unique between local and remote
 - 0.9.79: Fixed local collections not being considered for the synchronization unless all de-selected
 - 0.9.78: Added colored text! And also added a lot more customization options as to what to wipe, update, etc.

package/dist/appwrite/appwriteConfig.d.ts

@@ -0,0 +1,3 @@
+import { type AppwriteConfig } from "appwrite-utils";
+declare const appwriteConfig: AppwriteConfig;
+export default appwriteConfig;

package/dist/appwrite/appwriteConfig.js

@@ -0,0 +1,40 @@
+import {} from "appwrite-utils";
+const appwriteConfig = {
+    appwriteEndpoint: "https://appwrite.blackleafdigital.com/v1",
+    appwriteProject: "6717441100056a90bb20",
+    appwriteKey: "standard_f8664be4666240926caa1a2ed15a87424948036e3fd47b8d99a3de0cad83cdea7309ae30d004a3edd44c45292605f4a6b9c654aa44924a7cc5e3e95a77e0c9513d9c29a9059b7cf4fdafe626b67147d26de78390f946aeca22328f7ebdcdad159a644eb7589cacecdf4e397bd51362230cd319544a804db62d8edb968de1392a",
+    enableBackups: true,
+    backupInterval: 3600,
+    backupRetention: 30,
+    enableBackupCleanup: true,
+    enableMockData: false,
+    documentBucketId: "documents",
+    usersCollectionName: "Members",
+    databases: [
+        {
+            $id: "main",
+            name: "Main",
+            bucket: {
+                $id: "main_bucket",
+                name: "Main Bucket",
+                enabled: true,
+                maximumFileSize: 30000000,
+                allowedFileExtensions: [],
+                encryption: true,
+                antivirus: true
+            }
+        },
+    ],
+    buckets: [
+        {
+            $id: "global_bucket",
+            name: "Global Bucket",
+            enabled: true,
+            maximumFileSize: 30000000,
+            allowedFileExtensions: [],
+            encryption: true,
+            antivirus: true
+        }
+    ]
+};
+export default appwriteConfig;

package/dist/appwrite/collections/Album.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionCreate } from "appwrite-utils";
+declare const Album: Partial<CollectionCreate>;
+export default Album;

package/dist/appwrite/collections/Album.js

@@ -0,0 +1,58 @@
+const Album = {
+    $id: '01JASDQZ5TXZZ1Z9EVR5PKC10G',
+    documentSecurity: false,
+    enabled: true,
+    name: 'Album',
+    $permissions: [
+        { permission: 'read', target: 'any' },
+        { permission: 'create', target: 'users' },
+        { permission: 'update', target: 'users' },
+        { permission: 'delete', target: 'users' }
+    ],
+    attributes: [
+        {
+            key: 'title',
+            type: 'string',
+            size: 256,
+            required: true,
+        },
+        {
+            key: 'artistId',
+            type: 'string',
+            size: 36,
+            required: true,
+        },
+        {
+            key: 'releaseDate',
+            type: 'float',
+            min: 0,
+            required: true,
+        },
+        {
+            key: 'coverArtId',
+            type: 'string',
+            size: 36,
+            required: false,
+        },
+        {
+            key: 'genreIds',
+            type: 'string',
+            size: 36,
+            array: true,
+            required: false,
+        },
+    ],
+    indexes: [
+        {
+            key: 'title',
+            type: 'fulltext',
+            attributes: ['title'],
+        },
+        {
+            key: 'artistId',
+            type: 'key',
+            attributes: ['artistId'],
+        },
+    ],
+};
+export default Album;

package/dist/appwrite/collections/Artist.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionCreate } from "appwrite-utils";
+declare const Artist: Partial<CollectionCreate>;
+export default Artist;

package/dist/appwrite/collections/Artist.js

@@ -0,0 +1,65 @@
+const Artist = {
+    $id: '01JASCJ8AZ9V1Y5758ZXCWEA8Q',
+    documentSecurity: false,
+    enabled: true,
+    name: 'Artist',
+    $permissions: [
+        { permission: 'read', target: 'any' },
+        { permission: 'create', target: 'users' },
+        { permission: 'update', target: 'users' },
+        { permission: 'delete', target: 'users' }
+    ],
+    attributes: [
+        {
+            key: 'name',
+            type: 'string',
+            size: 256,
+            required: true,
+        },
+        {
+            key: 'bio',
+            type: 'string',
+            size: 1024,
+            required: false,
+        },
+        {
+            key: 'genreIds',
+            type: 'string',
+            size: 36,
+            array: true,
+            required: false,
+        },
+        {
+            key: 'profileImageId',
+            type: 'string',
+            size: 36,
+            required: false,
+        },
+        {
+            key: 'socialLinks',
+            type: 'string',
+            size: 256,
+            array: true,
+            required: false,
+        },
+        {
+            key: 'userId',
+            type: 'string',
+            size: 36,
+            required: true,
+        },
+    ],
+    indexes: [
+        {
+            key: 'name',
+            type: 'fulltext',
+            attributes: ['name'],
+        },
+        {
+            key: 'userId',
+            type: 'key',
+            attributes: ['userId'],
+        },
+    ],
+};
+export default Artist;

package/dist/appwrite/collections/Genre.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionCreate } from "appwrite-utils";
+declare const Genre: Partial<CollectionCreate>;
+export default Genre;

package/dist/appwrite/collections/Genre.js

@@ -0,0 +1,33 @@
+const Genre = {
+    $id: '01JASDXQDKAPCQBDW3NR5D9SBX',
+    documentSecurity: false,
+    enabled: true,
+    name: 'Genre',
+    $permissions: [
+        { permission: 'read', target: 'any' },
+        { permission: 'create', target: 'users' },
+        { permission: 'update', target: 'users' },
+        { permission: 'delete', target: 'users' }
+    ],
+    attributes: [
+        {
+            key: 'name',
+            type: 'string',
+            size: 64,
+            required: true,
+        },
+        {
+            key: 'description',
+            type: 'string',
+            size: 256,
+        },
+    ],
+    indexes: [
+        {
+            key: 'name',
+            type: 'fulltext',
+            attributes: ['name'],
+        },
+    ],
+};
+export default Genre;

package/dist/appwrite/collections/Playlist.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionCreate } from "appwrite-utils";
+declare const Playlist: Partial<CollectionCreate>;
+export default Playlist;

package/dist/appwrite/collections/Playlist.js

@@ -0,0 +1,55 @@
+const Playlist = {
+    $id: '01JASDR2H46MJQJZNS65T9B138',
+    documentSecurity: false,
+    enabled: true,
+    name: 'Playlist',
+    $permissions: [
+        { permission: 'read', target: 'any' },
+        { permission: 'create', target: 'users' },
+        { permission: 'update', target: 'users' },
+        { permission: 'delete', target: 'users' }
+    ],
+    attributes: [
+        {
+            key: 'name',
+            type: 'string',
+            size: 256,
+            required: true,
+        },
+        {
+            key: 'userId',
+            type: 'string',
+            size: 36,
+            required: true,
+        },
+        {
+            key: 'description',
+            type: 'string',
+            size: 1024,
+        },
+        {
+            key: 'isPublic',
+            type: 'boolean',
+            required: true,
+        },
+        {
+            key: 'songIds',
+            type: 'string',
+            size: 36,
+            array: true,
+        },
+    ],
+    indexes: [
+        {
+            key: 'name',
+            type: 'fulltext',
+            attributes: ['name'],
+        },
+        {
+            key: 'userId',
+            type: 'key',
+            attributes: ['userId'],
+        },
+    ],
+};
+export default Playlist;

package/dist/appwrite/collections/Song.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionCreate } from "appwrite-utils";
+declare const Song: Partial<CollectionCreate>;
+export default Song;

package/dist/appwrite/collections/Song.js

@@ -0,0 +1,88 @@
+const Song = {
+    $id: '01JASCJBWTMDS9K742CKDYD7S3',
+    documentSecurity: false,
+    enabled: true,
+    name: 'Song',
+    $permissions: [
+        { permission: 'read', target: 'any' },
+        { permission: 'create', target: 'users' },
+        { permission: 'update', target: 'users' },
+        { permission: 'delete', target: 'users' }
+    ],
+    attributes: [
+        {
+            key: 'title',
+            type: 'string',
+            size: 256,
+            required: true,
+        },
+        {
+            key: 'artistId',
+            type: 'string',
+            size: 36,
+            required: true,
+        },
+        {
+            key: 'featuredArtistIds',
+            type: 'string',
+            size: 36,
+            array: true,
+        },
+        {
+            key: 'albumId',
+            type: 'string',
+            size: 36,
+        },
+        {
+            key: 'duration',
+            type: 'float',
+            min: 0,
+            required: true,
+        },
+        {
+            key: 'genre',
+            type: 'string',
+            size: 64,
+        },
+        {
+            key: 'releaseDate',
+            type: 'float',
+            min: 0,
+            required: true,
+        },
+        {
+            key: 'audioFileId',
+            type: 'string',
+            size: 36,
+            required: true,
+        },
+        {
+            key: 'coverArtId',
+            type: 'string',
+            size: 36,
+        },
+        {
+            key: 'lyrics',
+            type: 'string',
+            size: 100000,
+        },
+    ],
+    indexes: [
+        {
+            key: 'title',
+            type: 'fulltext',
+            attributes: ['title'],
+        },
+        {
+            key: 'artistId',
+            type: 'key',
+            attributes: ['artistId'],
+        },
+        {
+            key: 'albumId',
+            type: 'key',
+            attributes: ['albumId'],
+        },
+    ],
+};
+export default Song;

package/dist/appwrite/collections/UserActivity.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionCreate } from "appwrite-utils";
+declare const UserActivity: Partial<CollectionCreate>;
+export default UserActivity;

package/dist/appwrite/collections/UserActivity.js

@@ -0,0 +1,51 @@
+const UserActivity = {
+    $id: '01JASDSEY956GTW8K4JWRV10G8',
+    documentSecurity: false,
+    enabled: true,
+    name: 'UserActivity',
+    $permissions: [
+        { permission: 'read', target: 'users' },
+        { permission: 'create', target: 'users' },
+        { permission: 'update', target: 'users' },
+        { permission: 'delete', target: 'users' }
+    ],
+    attributes: [
+        {
+            key: 'userId',
+            type: 'string',
+            size: 36,
+            required: true,
+        },
+        {
+            key: 'activityType',
+            type: 'string',
+            size: 64,
+            required: true,
+        },
+        {
+            key: 'targetId',
+            type: 'string',
+            size: 36,
+            required: true,
+        },
+        {
+            key: 'timestamp',
+            type: 'float',
+            min: 0,
+            required: true,
+        },
+    ],
+    indexes: [
+        {
+            key: 'userId',
+            type: 'key',
+            attributes: ['userId'],
+        },
+        {
+            key: 'activityType',
+            type: 'key',
+            attributes: ['activityType'],
+        },
+    ],
+};
+export default UserActivity;

package/dist/appwrite/collections/UserData.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionCreate } from "appwrite-utils";
+declare const UserData: Partial<CollectionCreate>;
+export default UserData;

package/dist/appwrite/collections/UserData.js

@@ -0,0 +1,33 @@
+const UserData = {
+    $id: '01JASCH88CF1CVXBXY488WFF2Z',
+    documentSecurity: false,
+    enabled: true,
+    name: 'UserData',
+    $permissions: [
+        { permission: 'read', target: 'any' },
+        { permission: 'create', target: 'any' },
+        { permission: 'update', target: 'label:admin' },
+        { permission: 'delete', target: 'label:admin' }
+    ],
+    attributes: [
+        {
+            key: 'address',
+            type: 'string',
+            size: 256,
+            required: true
+        },
+        {
+            key: 'bio',
+            type: 'string',
+            size: 1024,
+        }
+    ],
+    indexes: [
+        {
+            key: 'UniqueAddress',
+            type: 'unique',
+            attributes: ['address']
+        }
+    ],
+};
+export default UserData;

package/dist/appwrite/schemas/album.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const AlbumSchemaBase: z.ZodObject<{
+    $id: z.ZodOptional<z.ZodString>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    artistId: z.ZodString;
+    releaseDate: z.ZodNumber;
+    coverArtId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    genreIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    artistId: string;
+    releaseDate: number;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    coverArtId?: string | null | undefined;
+    genreIds?: string[] | null | undefined;
+}, {
+    title: string;
+    artistId: string;
+    releaseDate: number;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    coverArtId?: string | null | undefined;
+    genreIds?: string[] | null | undefined;
+}>;
+export type AlbumBase = z.infer<typeof AlbumSchemaBase>;
+export declare const AlbumSchema: z.ZodType<AlbumBase>;
+export type Album = z.infer<typeof AlbumSchema>;

package/dist/appwrite/schemas/album.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const AlbumSchemaBase = z.object({
+    $id: z.string().optional(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    title: z.string().max(256, "Maximum length of 256 characters exceeded"),
+    artistId: z.string().max(36, "Maximum length of 36 characters exceeded"),
+    releaseDate: z.number().min(0, "Minimum value of 0 not met"),
+    coverArtId: z.string().max(36, "Maximum length of 36 characters exceeded").nullish(),
+    genreIds: z.array(z.string().max(36, "Maximum length of 36 characters exceeded")).nullish(),
+});
+export const AlbumSchema = AlbumSchemaBase;

package/dist/appwrite/schemas/artist.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export declare const ArtistSchemaBase: z.ZodObject<{
+    $id: z.ZodOptional<z.ZodString>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    bio: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    genreIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    profileImageId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    socialLinks: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    userId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    userId: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    genreIds?: string[] | null | undefined;
+    bio?: string | null | undefined;
+    profileImageId?: string | null | undefined;
+    socialLinks?: string[] | null | undefined;
+}, {
+    name: string;
+    userId: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    genreIds?: string[] | null | undefined;
+    bio?: string | null | undefined;
+    profileImageId?: string | null | undefined;
+    socialLinks?: string[] | null | undefined;
+}>;
+export type ArtistBase = z.infer<typeof ArtistSchemaBase>;
+export declare const ArtistSchema: z.ZodType<ArtistBase>;
+export type Artist = z.infer<typeof ArtistSchema>;

package/dist/appwrite/schemas/artist.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const ArtistSchemaBase = z.object({
+    $id: z.string().optional(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    name: z.string().max(256, "Maximum length of 256 characters exceeded"),
+    bio: z.string().max(1024, "Maximum length of 1024 characters exceeded").nullish(),
+    genreIds: z.array(z.string().max(36, "Maximum length of 36 characters exceeded")).nullish(),
+    profileImageId: z.string().max(36, "Maximum length of 36 characters exceeded").nullish(),
+    socialLinks: z.array(z.string().max(256, "Maximum length of 256 characters exceeded")).nullish(),
+    userId: z.string().max(36, "Maximum length of 36 characters exceeded"),
+});
+export const ArtistSchema = ArtistSchemaBase;

package/dist/appwrite/schemas/genre.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const GenreSchemaBase: z.ZodObject<{
+    $id: z.ZodOptional<z.ZodString>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    description?: string | null | undefined;
+}, {
+    name: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    description?: string | null | undefined;
+}>;
+export type GenreBase = z.infer<typeof GenreSchemaBase>;
+export declare const GenreSchema: z.ZodType<GenreBase>;
+export type Genre = z.infer<typeof GenreSchema>;

package/dist/appwrite/schemas/genre.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const GenreSchemaBase = z.object({
+    $id: z.string().optional(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    name: z.string().max(64, "Maximum length of 64 characters exceeded"),
+    description: z.string().max(256, "Maximum length of 256 characters exceeded").nullish(),
+});
+export const GenreSchema = GenreSchemaBase;

package/dist/appwrite/schemas/playlist.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const PlaylistSchemaBase: z.ZodObject<{
+    $id: z.ZodOptional<z.ZodString>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    userId: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isPublic: z.ZodBoolean;
+    songIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    userId: string;
+    isPublic: boolean;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    description?: string | null | undefined;
+    songIds?: string[] | null | undefined;
+}, {
+    name: string;
+    userId: string;
+    isPublic: boolean;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    description?: string | null | undefined;
+    songIds?: string[] | null | undefined;
+}>;
+export type PlaylistBase = z.infer<typeof PlaylistSchemaBase>;
+export declare const PlaylistSchema: z.ZodType<PlaylistBase>;
+export type Playlist = z.infer<typeof PlaylistSchema>;

package/dist/appwrite/schemas/playlist.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const PlaylistSchemaBase = z.object({
+    $id: z.string().optional(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    name: z.string().max(256, "Maximum length of 256 characters exceeded"),
+    userId: z.string().max(36, "Maximum length of 36 characters exceeded"),
+    description: z.string().max(1024, "Maximum length of 1024 characters exceeded").nullish(),
+    isPublic: z.boolean(),
+    songIds: z.array(z.string().max(36, "Maximum length of 36 characters exceeded")).nullish(),
+});
+export const PlaylistSchema = PlaylistSchemaBase;

package/dist/appwrite/schemas/song.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const SongSchemaBase: z.ZodObject<{
+    $id: z.ZodOptional<z.ZodString>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    artistId: z.ZodString;
+    featuredArtistIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    albumId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    duration: z.ZodNumber;
+    genre: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    releaseDate: z.ZodNumber;
+    audioFileId: z.ZodString;
+    coverArtId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lyrics: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    artistId: string;
+    releaseDate: number;
+    duration: number;
+    audioFileId: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    coverArtId?: string | null | undefined;
+    featuredArtistIds?: string[] | null | undefined;
+    albumId?: string | null | undefined;
+    genre?: string | null | undefined;
+    lyrics?: string | null | undefined;
+}, {
+    title: string;
+    artistId: string;
+    releaseDate: number;
+    duration: number;
+    audioFileId: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    coverArtId?: string | null | undefined;
+    featuredArtistIds?: string[] | null | undefined;
+    albumId?: string | null | undefined;
+    genre?: string | null | undefined;
+    lyrics?: string | null | undefined;
+}>;
+export type SongBase = z.infer<typeof SongSchemaBase>;
+export declare const SongSchema: z.ZodType<SongBase>;
+export type Song = z.infer<typeof SongSchema>;

package/dist/appwrite/schemas/song.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const SongSchemaBase = z.object({
+    $id: z.string().optional(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    title: z.string().max(256, "Maximum length of 256 characters exceeded"),
+    artistId: z.string().max(36, "Maximum length of 36 characters exceeded"),
+    featuredArtistIds: z.array(z.string().max(36, "Maximum length of 36 characters exceeded")).nullish(),
+    albumId: z.string().max(36, "Maximum length of 36 characters exceeded").nullish(),
+    duration: z.number().min(0, "Minimum value of 0 not met"),
+    genre: z.string().max(64, "Maximum length of 64 characters exceeded").nullish(),
+    releaseDate: z.number().min(0, "Minimum value of 0 not met"),
+    audioFileId: z.string().max(36, "Maximum length of 36 characters exceeded"),
+    coverArtId: z.string().max(36, "Maximum length of 36 characters exceeded").nullish(),
+    lyrics: z.string().max(100000, "Maximum length of 100000 characters exceeded").nullish(),
+});
+export const SongSchema = SongSchemaBase;

package/dist/appwrite/schemas/userActivity.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const UserActivitySchemaBase: z.ZodObject<{
+    $id: z.ZodOptional<z.ZodString>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    userId: z.ZodString;
+    activityType: z.ZodString;
+    targetId: z.ZodString;
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    activityType: string;
+    targetId: string;
+    timestamp: number;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+}, {
+    userId: string;
+    activityType: string;
+    targetId: string;
+    timestamp: number;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+}>;
+export type UserActivityBase = z.infer<typeof UserActivitySchemaBase>;
+export declare const UserActivitySchema: z.ZodType<UserActivityBase>;
+export type UserActivity = z.infer<typeof UserActivitySchema>;

package/dist/appwrite/schemas/userActivity.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const UserActivitySchemaBase = z.object({
+    $id: z.string().optional(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    userId: z.string().max(36, "Maximum length of 36 characters exceeded"),
+    activityType: z.string().max(64, "Maximum length of 64 characters exceeded"),
+    targetId: z.string().max(36, "Maximum length of 36 characters exceeded"),
+    timestamp: z.number().min(0, "Minimum value of 0 not met"),
+});
+export const UserActivitySchema = UserActivitySchemaBase;

package/dist/appwrite/schemas/userData.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const UserDataSchemaBase: z.ZodObject<{
+    $id: z.ZodOptional<z.ZodString>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    address: z.ZodString;
+    bio: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    bio?: string | null | undefined;
+}, {
+    address: string;
+    $id?: string | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    bio?: string | null | undefined;
+}>;
+export type UserDataBase = z.infer<typeof UserDataSchemaBase>;
+export declare const UserDataSchema: z.ZodType<UserDataBase>;
+export type UserData = z.infer<typeof UserDataSchema>;

package/dist/appwrite/schemas/userData.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const UserDataSchemaBase = z.object({
+    $id: z.string().optional(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    address: z.string().max(256, "Maximum length of 256 characters exceeded"),
+    bio: z.string().max(1024, "Maximum length of 1024 characters exceeded").nullish(),
+});
+export const UserDataSchema = UserDataSchemaBase;

package/dist/utils/loadConfigs.js

@@ -36,15 +36,25 @@ export const loadConfig = async (configDir) => {
         const configPath = path.join(configDir, "appwriteConfig.ts");
         console.log(`Loading config from: ${configPath}`);
         const configUrl = pathToFileURL(configPath).href;
-        const config = (await import(configUrl)).default;
+        const configModule = (await import(configUrl));
+        const config = configModule.default?.default || configModule.default || configModule;
+        if (!config) {
+            throw new Error("Failed to load config");
+        }
         const collectionsDir = path.join(configDir, "collections");
         const collectionFiles = fs.readdirSync(collectionsDir);
         config.collections = [];
         for (const file of collectionFiles) {
+            if (file === "index.ts") {
+                continue;
+            }
             const filePath = path.join(collectionsDir, file);
             const fileUrl = pathToFileURL(filePath).href;
-            const collectionModule = (await import(fileUrl)).default;
-            config.collections.push(collectionModule);
+            const collectionModule = (await import(fileUrl));
+            const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
+            if (collection) {
+                config.collections.push(collection);
+            }
         }
         return config;
     }

package/dist/utils/schemaStrings.js

@@ -172,7 +172,6 @@ export class SchemaGenerator {
             return;
         }
         this.config.collections.forEach((collection) => {
-            console.log(`Generating schema for ${JSON.stringify(collection, null, 4)}`);
             const schemaString = this.createSchemaString(collection.name, collection.attributes);
             const camelCaseName = toCamelCase(collection.name);
             const schemaPath = path.join(this.appwriteFolderPath, "schemas", `${camelCaseName}.ts`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.9.89",
+  "version": "0.9.91",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/utils/loadConfigs.ts

@@ -41,18 +41,27 @@ export const loadConfig = async (
     const configPath = path.join(configDir, "appwriteConfig.ts");
     console.log(`Loading config from: ${configPath}`);
     const configUrl = pathToFileURL(configPath).href;
-    const config = (await import(configUrl)).default as AppwriteConfig;
-
+    const configModule = (await import(configUrl));
+    const config: AppwriteConfig | undefined = configModule.default?.default || configModule.default || configModule;
+    if (!config) {
+      throw new Error("Failed to load config");
+    }
     const collectionsDir = path.join(configDir, "collections");
     const collectionFiles = fs.readdirSync(collectionsDir);
 
     config.collections = [];
 
     for (const file of collectionFiles) {
+      if (file === "index.ts") {
+        continue;
+      }
       const filePath = path.join(collectionsDir, file);
       const fileUrl = pathToFileURL(filePath).href;
-      const collectionModule = (await import(fileUrl)).default as Collection;
-      config.collections.push(collectionModule);
+      const collectionModule = (await import(fileUrl));
+      const collection: Collection | undefined = collectionModule.default?.default || collectionModule.default || collectionModule;
+      if (collection) {
+        config.collections.push(collection);
+      }
     }
 
     return config;

package/src/utils/schemaStrings.ts

@@ -226,7 +226,6 @@ export class SchemaGenerator {
       return;
     }
     this.config.collections.forEach((collection) => {
-      console.log(`Generating schema for ${JSON.stringify(collection, null, 4)}`);
       const schemaString = this.createSchemaString(
         collection.name,
         collection.attributes

package/tsconfig.json

@@ -33,5 +33,5 @@
     "declaration": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "src/appwrite", "example/*"]
+  "exclude": ["node_modules", "dist", "src/_test/appwrite", "example/*"]
 }