appwrite-utils-cli 0.0.1

package/dist/migrations/users.js

@@ -0,0 +1,114 @@
+import { Databases, ID, Query, Users } from "node-appwrite";
+import { AuthUserSchema, } from "../schemas/authUser.js";
+import _ from "lodash";
+export class UsersController {
+    config;
+    users;
+    static userFields = [
+        "email",
+        "name",
+        "password",
+        "phone",
+        "labels",
+        "prefs",
+        "userId",
+        "$createdAt",
+        "$updatedAt",
+    ];
+    constructor(config, db) {
+        this.config = config;
+        this.users = new Users(this.config.appwriteClient);
+    }
+    async wipeUsers() {
+        const users = await this.users.list([Query.limit(25)]);
+        const allUsers = users.users;
+        let lastDocumentId;
+        if (users.total > 25) {
+            lastDocumentId = users.users[users.users.length - 1].$id;
+        }
+        while (lastDocumentId) {
+            const moreUsers = await this.users.list([
+                Query.limit(25),
+                Query.cursorAfter(lastDocumentId),
+            ]);
+            allUsers.push(...moreUsers.users);
+            lastDocumentId = moreUsers.users[moreUsers.users.length - 1].$id;
+        }
+        console.log("Deleting all users");
+        for (const user of allUsers) {
+            await this.users.delete(user.$id);
+        }
+    }
+    async createUserAndReturn(item) {
+        console.log("Creating user with item", item);
+        // Attempt to find an existing user by email or phone.
+        let foundUsers = [];
+        if (item.email) {
+            const foundUsersByEmail = await this.users.list([
+                Query.equal("email", item.email),
+            ]);
+            foundUsers = foundUsersByEmail.users;
+        }
+        if (item.phone) {
+            const foundUsersByPhone = await this.users.list([
+                Query.equal("phone", item.phone),
+            ]);
+            foundUsers = foundUsers.length
+                ? foundUsers.concat(foundUsersByPhone.users)
+                : foundUsersByPhone.users;
+        }
+        let userToReturn = foundUsers[0] || undefined;
+        if (!userToReturn) {
+            console.log("Creating user cause not found");
+            userToReturn = await this.users.create(item.userId || ID.unique(), item.email || undefined, item.phone && item.phone.length < 15 && item.phone.startsWith("+")
+                ? item.phone
+                : undefined, item.password?.toLowerCase() || `changeMe${item.email}`.toLowerCase(), item.name || undefined);
+        }
+        else {
+            console.log("Updating user cause found");
+            // Update user details as necessary, ensuring email uniqueness if attempting an update.
+            if (item.email &&
+                item.email !== userToReturn.email &&
+                !_.isEmpty(item.email) &&
+                !_.isUndefined(item.email)) {
+                const emailExists = await this.users.list([
+                    Query.equal("email", item.email),
+                ]);
+                if (emailExists.users.length === 0) {
+                    userToReturn = await this.users.updateEmail(userToReturn.$id, item.email);
+                }
+                else {
+                    console.log("Email update skipped: Email already exists.");
+                }
+            }
+            if (item.password) {
+                userToReturn = await this.users.updatePassword(userToReturn.$id, item.password.toLowerCase());
+            }
+            if (item.name && item.name !== userToReturn.name) {
+                userToReturn = await this.users.updateName(userToReturn.$id, item.name);
+            }
+            if (item.phone &&
+                item.phone !== userToReturn.phone &&
+                item.phone.length < 15 &&
+                item.phone.startsWith("+") &&
+                (_.isUndefined(userToReturn.phone) || _.isEmpty(userToReturn.phone))) {
+                const userFoundWithPhone = await this.users.list([
+                    Query.equal("phone", item.phone),
+                ]);
+                if (userFoundWithPhone.total === 0) {
+                    userToReturn = await this.users.updatePhone(userToReturn.$id, item.phone);
+                }
+            }
+        }
+        if (item.$createdAt && item.$updatedAt) {
+            console.log("$createdAt and $updatedAt are not yet supported, sorry about that!");
+        }
+        if (item.labels && item.labels.length) {
+            userToReturn = await this.users.updateLabels(userToReturn.$id, item.labels);
+        }
+        if (item.prefs && Object.keys(item.prefs).length) {
+            userToReturn = await this.users.updatePrefs(userToReturn.$id, item.prefs);
+        }
+        return userToReturn;
+    }
+}

package/dist/migrations/validationRules.d.ts

@@ -0,0 +1,43 @@
+export interface ValidationRules {
+    [key: string]: (value: any, ...args: any[]) => boolean;
+}
+export declare const validationRules: {
+    isNumber: (value: any) => boolean;
+    isString: (value: any) => boolean;
+    isBoolean: (value: any) => boolean;
+    isArray: (value: any) => boolean;
+    isObject: (value: any) => boolean;
+    isNull: (value: any) => boolean;
+    isValidEmail: (value: string) => boolean;
+    isValidPhone: (value: string) => boolean;
+    isValidPassword: (value: string) => boolean;
+    isValidUrl: (value: string) => boolean;
+    isValidHex: (value: string) => boolean;
+    isValidHexColor: (value: string) => boolean;
+    isValidHexAlpha: (value: string) => boolean;
+    isValidDate: (value: string) => boolean;
+    isValidTime: (value: string) => boolean;
+    isNullish: (value: any) => boolean;
+    isUndefined: (value: any) => boolean;
+    isDefined: (value: any) => boolean;
+    isDate: (value: any) => boolean;
+    isEmpty: (value: any) => boolean;
+    isInteger: (value: any) => boolean;
+    isFloat: (value: any) => boolean;
+    isArrayLike: (value: any) => boolean;
+    isArrayLikeObject: (value: any) => boolean;
+    isFunction: (value: any) => boolean;
+    isLength: (value: any) => boolean;
+    isMap: (value: any) => boolean;
+    isSet: (value: any) => boolean;
+    isRegExp: (value: any) => boolean;
+    isSymbol: (value: any) => boolean;
+    isObjectLike: (value: any) => boolean;
+    isPlainObject: (value: any) => boolean;
+    isSafeInteger: (value: any) => boolean;
+    isTypedArray: (value: any) => boolean;
+    isEqual: (value: any, other: any) => boolean;
+    isMatch: (object: any, source: any) => boolean;
+    has: (object: any, path: string) => boolean;
+    get: (object: any, path: string, defaultValue: any) => any;
+};

package/dist/migrations/validationRules.js

@@ -0,0 +1,42 @@
+import _ from "lodash";
+export const validationRules = {
+    isNumber: (value) => _.isNumber(value),
+    isString: (value) => _.isString(value),
+    isBoolean: (value) => _.isBoolean(value),
+    isArray: (value) => _.isArray(value),
+    isObject: (value) => _.isObject(value) && !_.isArray(value) && !_.isFunction(value),
+    isNull: (value) => _.isNull(value),
+    isValidEmail: (value) => value.match(/^[\w\-\.]+@([\w-]+\.)+[\w-]{2,}$/) !== null,
+    isValidPhone: (value) => value.match(/^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im) !==
+        null,
+    isValidPassword: (value) => value.match(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/) !== null,
+    isValidUrl: (value) => value.match(/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/) !== null,
+    isValidHex: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
+    isValidHexColor: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
+    isValidHexAlpha: (value) => value.match(/^#([a-f0-9]{8}|[a-f0-9]{4})$/i) !== null,
+    isValidDate: (value) => value.match(/^\d{4}-\d{2}-\d{2}$/) !== null,
+    isValidTime: (value) => value.match(/^\d{2}:\d{2}(:\d{2})?$/) !== null,
+    isNullish: (value) => _.isNull(value) || _.isUndefined(value),
+    isUndefined: (value) => _.isUndefined(value),
+    isDefined: (value) => !_.isUndefined(value) && !_.isNull(value) && !_.isEmpty(value),
+    isDate: (value) => _.isDate(value),
+    isEmpty: (value) => _.isEmpty(value),
+    isInteger: (value) => _.isInteger(value),
+    isFloat: (value) => _.isNumber(value) && !_.isInteger(value),
+    isArrayLike: (value) => _.isArrayLike(value),
+    isArrayLikeObject: (value) => _.isArrayLikeObject(value),
+    isFunction: (value) => _.isFunction(value),
+    isLength: (value) => _.isLength(value),
+    isMap: (value) => _.isMap(value),
+    isSet: (value) => _.isSet(value),
+    isRegExp: (value) => _.isRegExp(value),
+    isSymbol: (value) => _.isSymbol(value),
+    isObjectLike: (value) => _.isObjectLike(value),
+    isPlainObject: (value) => _.isPlainObject(value),
+    isSafeInteger: (value) => _.isSafeInteger(value),
+    isTypedArray: (value) => _.isTypedArray(value),
+    isEqual: (value, other) => _.isEqual(value, other),
+    isMatch: (object, source) => _.isMatch(object, source),
+    has: (object, path) => _.has(object, path),
+    get: (object, path, defaultValue) => _.get(object, path, defaultValue),
+};

package/dist/schemas/authUser.d.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+export declare const AuthUserSchema: z.ZodObject<{
+    $id: z.ZodString;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    prefs: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    labels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    $id: string;
+    prefs: Record<string, string>;
+    labels: string[];
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    name?: string | null | undefined;
+    email?: string | null | undefined;
+    phone?: string | null | undefined;
+}, {
+    $id: string;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    name?: string | null | undefined;
+    email?: string | null | undefined;
+    phone?: string | null | undefined;
+    prefs?: Record<string, string> | undefined;
+    labels?: string[] | undefined;
+}>;
+export type AuthUser = z.infer<typeof AuthUserSchema>;
+export declare const AuthUserCreateSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    $createdAt: z.ZodOptional<z.ZodString>;
+    $updatedAt: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    prefs: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    labels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    userId: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prefs: Record<string, string>;
+    labels: string[];
+    email?: string | null | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    name?: string | null | undefined;
+    phone?: string | null | undefined;
+    userId?: string | undefined;
+    password?: string | undefined;
+}, {
+    email?: string | null | undefined;
+    $createdAt?: string | undefined;
+    $updatedAt?: string | undefined;
+    name?: string | null | undefined;
+    phone?: string | null | undefined;
+    prefs?: Record<string, string> | undefined;
+    labels?: string[] | undefined;
+    userId?: string | undefined;
+    password?: string | undefined;
+}>;
+export type AuthUserCreate = z.infer<typeof AuthUserCreateSchema>;

package/dist/schemas/authUser.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const AuthUserSchema = z.object({
+    $id: z.string(),
+    $createdAt: z.string().optional(),
+    $updatedAt: z.string().optional(),
+    name: z.string().nullish(),
+    email: z.string().nullish(),
+    phone: z.string().nullish(),
+    prefs: z.record(z.string()).optional().default({}),
+    labels: z.array(z.string()).optional().default([]),
+});
+export const AuthUserCreateSchema = AuthUserSchema.omit({
+    $id: true,
+}).extend({
+    userId: z.string().optional(),
+    password: z.string().optional(),
+});

package/dist/setup.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/setup.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { setupDirsFiles } from "./utils/setupFiles.js";
+const args = process.argv.slice(2);
+const genExample = args.includes("--example");
+setupDirsFiles(genExample);

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+export type { AppwriteConfig } from "./migrations/schema.js";
+export type { ConverterFunctions } from "./migrations/converters.js";
+export type { ValidationRules } from "./migrations/validationRules.js";
+export type { AfterImportActions } from "./migrations/afterImportActions.js";
+export { type AuthUserCreate, AuthUserCreateSchema, type AuthUser, AuthUserSchema, } from "./schemas/authUser.js";
+export { getFileViewUrl, getFileDownloadUrl } from "./utils/helperFunctions.js";
+export { converterFunctions } from "./migrations/converters.js";
+export { validationRules } from "./migrations/validationRules.js";
+export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/types.js

@@ -0,0 +1,5 @@
+export { AuthUserCreateSchema, AuthUserSchema, } from "./schemas/authUser.js";
+export { getFileViewUrl, getFileDownloadUrl } from "./utils/helperFunctions.js";
+export { converterFunctions } from "./migrations/converters.js";
+export { validationRules } from "./migrations/validationRules.js";
+export { afterImportActions } from "./migrations/afterImportActions.js";