npm - @flowerforce/flowerbase - Versions diffs - 1.4.2-beta.2 → 1.4.2-beta.4 - Mend

@flowerforce/flowerbase 1.4.2-beta.2 → 1.4.2-beta.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/auth/controller.d.ts.map +1 -1
package/dist/auth/controller.js +8 -0
package/dist/auth/providers/anon-user/controller.d.ts.map +1 -1
package/dist/auth/providers/anon-user/controller.js +9 -15
package/dist/auth/utils.js +8 -8
package/dist/services/aws/index.d.ts +9 -6
package/dist/services/aws/index.d.ts.map +1 -1
package/dist/services/aws/index.js +25 -18
package/dist/services/index.d.ts +8 -4
package/dist/services/index.d.ts.map +1 -1
package/dist/utils/context/helpers.d.ts +24 -12
package/dist/utils/context/helpers.d.ts.map +1 -1
package/package.json +3 -2
package/src/auth/__tests__/controller.test.ts +51 -0
package/src/auth/controller.ts +11 -0
package/src/auth/providers/anon-user/__tests__/controller.test.ts +82 -0
package/src/auth/providers/anon-user/controller.ts +9 -19
package/src/auth/utils.ts +8 -8
package/src/services/aws/index.ts +47 -20

package/dist/auth/controller.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/auth/controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAQzC;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,eAAe,~~iBA+IxD~~"}
1	+ {"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/auth/controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAQzC;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,eAAe,iBA0JxD"}

package/dist/auth/controller.js CHANGED Viewed

@@ -31,6 +31,14 @@ function authController(app) {
         catch (error) {
             console.error('Failed to ensure refresh token TTL index', error);
         }
+        try {
+            yield db.collection(authCollection).createIndex({ email: 1 }, {
+                unique: true
+            });
+        }
+        catch (error) {
+            console.error('Failed to ensure auth email unique index', error);
+        }
         app.addHook(HANDLER_TYPE, app.jwtAuthentication);
         /**
          * Endpoint to retrieve the authenticated user's profile.

package/dist/auth/providers/anon-user/controller.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../../src/auth/providers/anon-user/controller.ts"],"names":[],"mappings":"~~AAAA~~,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAOzC;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,eAAe,~~iBA8E5D~~"}
1	+ {"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../../src/auth/providers/anon-user/controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAOzC;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,eAAe,iBAmE5D"}

package/dist/auth/providers/anon-user/controller.js CHANGED Viewed

@@ -10,9 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.anonUserController = anonUserController;
+const bson_1 = require("bson");
 const constants_1 = require("../../../constants");
-const crypto_1 = require("../../../utils/crypto");
 const handleUserRegistration_model_1 = require("../../../shared/models/handleUserRegistration.model");
+const crypto_1 = require("../../../utils/crypto");
 const utils_1 = require("../../utils");
 /**
  * Controller for handling anonymous user login.
@@ -41,30 +42,23 @@ function anonUserController(app) {
                     throw new Error('Anonymous authentication disabled');
                 }
                 const now = new Date();
-                const insertResult = yield db.collection(authCollection).insertOne({
+                const userId = new bson_1.ObjectId();
+                const anonEmail = `anon-${userId.toString()}@users.invalid`;
+                yield db.collection(authCollection).insertOne({
+                    _id: userId,
+                    email: anonEmail,
                     status: 'confirmed',
                     createdAt: now,
                     custom_data: {},
                     identities: [
                         {
+                            id: userId.toString(),
+                            provider_id: userId.toString(),
                             provider_type: handleUserRegistration_model_1.PROVIDER.ANON_USER,
                             provider_data: {}
                         }
                     ]
                 });
-                const userId = insertResult.insertedId;
-                yield db.collection(authCollection).updateOne({ _id: userId }, {
-                    $set: {
-                        identities: [
-                            {
-                                id: userId.toString(),
-                                provider_id: userId.toString(),
-                                provider_type: handleUserRegistration_model_1.PROVIDER.ANON_USER,
-                                provider_data: {}
-                            }
-                        ]
-                    }
-                });
                 const currentUserData = {
                     _id: userId,
                     user_data: {}

package/dist/auth/utils.js CHANGED Viewed

@@ -15,10 +15,10 @@ exports.LOGIN_SCHEMA = {
             username: {
                 type: 'string',
                 pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-                minLength: 3,
+                minLength: 5,
                 maxLength: 254
             },
-            password: { type: 'string', minLength: 8, maxLength: 128 }
+            password: { type: 'string', minLength: 6, maxLength: 128 }
         },
         required: ['username', 'password']
     }
@@ -30,7 +30,7 @@ exports.RESET_SEND_SCHEMA = {
             email: {
                 type: 'string',
                 pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-                minLength: 3,
+                minLength: 5,
                 maxLength: 254
             }
         },
@@ -44,10 +44,10 @@ exports.RESET_CALL_SCHEMA = {
             email: {
                 type: 'string',
                 pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-                minLength: 3,
+                minLength: 5,
                 maxLength: 254
             },
-            password: { type: 'string', minLength: 8, maxLength: 128 },
+            password: { type: 'string', minLength: 6, maxLength: 128 },
             arguments: { type: 'array' }
         },
         required: ['email', 'password']
@@ -57,7 +57,7 @@ exports.CONFIRM_RESET_SCHEMA = {
     body: {
         type: 'object',
         properties: {
-            password: { type: 'string', minLength: 8, maxLength: 128 },
+            password: { type: 'string', minLength: 6, maxLength: 128 },
             token: { type: 'string' },
             tokenId: { type: 'string' }
         },
@@ -82,10 +82,10 @@ exports.REGISTRATION_SCHEMA = {
             email: {
                 type: 'string',
                 pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-                minLength: 3,
+                minLength: 5,
                 maxLength: 254
             },
-            password: { type: 'string', minLength: 8, maxLength: 128 }
+            password: { type: 'string', minLength: 6, maxLength: 128 }
         },
         required: ['email', 'password']
     }

package/dist/services/aws/index.d.ts CHANGED Viewed

@@ -1,11 +1,14 @@
-import { AWSError } from 'aws-sdk';
-import Lambda from 'aws-sdk/clients/lambda';
-import S3 from 'aws-sdk/clients/s3';
-import { PromiseResult } from 'aws-sdk/lib/request';
+import { InvokeAsyncCommandInput, InvokeAsyncCommandOutput, InvokeCommandInput, InvokeCommandOutput, Lambda } from '@aws-sdk/client-lambda';
+import { S3 } from '@aws-sdk/client-s3';
+type LambdaInvokeResponse = Omit<InvokeCommandOutput, 'Payload'> & {
+    Payload: {
+        text: () => string | undefined;
+    };
+};
 declare const Aws: () => {
     lambda: (region: string) => Lambda & {
-        Invoke: (...args: Parameters<Lambda["invoke"]>) => Promise<PromiseResult<Lambda.InvocationResponse, AWSError>>;
-        InvokeAsync: Lambda["invokeAsync"];
+        Invoke: (params: InvokeCommandInput) => Promise<LambdaInvokeResponse>;
+        InvokeAsync: (params: InvokeAsyncCommandInput) => Promise<InvokeAsyncCommandOutput>;
     };
     s3: (region: string) => S3;
 };

package/dist/services/aws/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/aws/index.ts"],"names":[],"mappings":"AAAA,OAAO,~~EAAE~~,~~QAAQ~~,~~EAAe~~,~~MAAM~~,~~SAAS~~,~~CAAA;AAC/C~~,~~OAAO~~,MAAM,MAAM,wBAAwB,CAAA;~~AAC3C~~,OAAO,EAAE,MAAM,oBAAoB,CAAA;~~AACnC~~,OAAO,EAAE,~~aAAa~~,EAAE,MAAM,~~qBAAqB~~,CAAA;~~AAInD~~,QAAA,MAAM,GAAG;~~qBAQY~~,MAAM;gBAKX,~~CACN,GAAG,IAAI,EAAE,UAAU,~~CAAC,MAAM,~~CAAC~~,~~QAAQ~~,~~CAAC~~,~~CAAC,KAClC,~~OAAO,CAAC,~~aAAa~~,CAAC,~~MAAM,~~CAAC,~~kBAAkB~~,EAAE,~~QAAQ~~,~~CAAC~~,~~CAAC;qBACnD~~,~~MAAM,~~CAAC,~~aAAa~~,CAAC;;~~iBAczB~~,MAAM;~~CAStB~~,CAAA;AAED,eAAe,GAAG,CAAA"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/aws/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,uBAAuB,EACvB,wBAAwB,EAExB,kBAAkB,EAClB,mBAAmB,EACnB,MAAM,EACP,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAA;AAGvC,KAAK,oBAAoB,GAAG,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC,GAAG;IACjE,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,MAAM,GAAG,SAAS,CAAA;KAC/B,CAAA;CACF,CAAA;AAUD,QAAA,MAAM,GAAG;qBAUY,MAAM;gBAKX,CAAC,MAAM,EAAE,kBAAkB,KAAK,OAAO,CAAC,oBAAoB,CAAC;qBACxD,CAAC,MAAM,EAAE,uBAAuB,KAAK,OAAO,CAAC,wBAAwB,CAAC;;iBAwB1E,MAAM;CAOtB,CAAA;AAED,eAAe,GAAG,CAAA"}

package/dist/services/aws/index.js CHANGED Viewed

@@ -8,39 +8,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const lambda_1 = __importDefault(require("aws-sdk/clients/lambda"));
-const s3_1 = __importDefault(require("aws-sdk/clients/s3"));
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const client_s3_1 = require("@aws-sdk/client-s3");
 const constants_1 = require("../../constants");
+const decodePayload = (payload) => {
+    if (!payload) {
+        return undefined;
+    }
+    return Buffer.from(payload).toString('utf-8');
+};
 const Aws = () => {
-    const credentials = {
-        accessKeyId: constants_1.S3_CONFIG.ACCESS_KEY_ID,
-        secretAccessKey: constants_1.S3_CONFIG.SECRET_ACCESS_KEY,
-    };
+    const credentials = constants_1.S3_CONFIG.ACCESS_KEY_ID && constants_1.S3_CONFIG.SECRET_ACCESS_KEY
+        ? {
+            accessKeyId: constants_1.S3_CONFIG.ACCESS_KEY_ID,
+            secretAccessKey: constants_1.S3_CONFIG.SECRET_ACCESS_KEY
+        }
+        : undefined;
     return {
         lambda: (region) => {
-            const lambda = new lambda_1.default({
+            const lambda = new client_lambda_1.Lambda({
                 region: region,
                 credentials
             });
-            lambda.Invoke = (...args) => __awaiter(void 0, void 0, void 0, function* () {
-                const res = yield lambda.invoke(...args).promise();
+            lambda.Invoke = (params) => __awaiter(void 0, void 0, void 0, function* () {
+                const res = yield lambda.send(new client_lambda_1.InvokeCommand(params));
                 return Object.assign(Object.assign({}, res), { Payload: {
-                        text: () => res.Payload
+                        text: () => decodePayload(res.Payload)
                     } });
             });
-            lambda.InvokeAsync = lambda.invokeAsync;
+            const invokeAsync = (params) => __awaiter(void 0, void 0, void 0, function* () {
+                return lambda.send(new client_lambda_1.InvokeAsyncCommand(params));
+            });
+            lambda.InvokeAsync = invokeAsync;
+            lambda.invokeAsync = invokeAsync;
             return lambda;
         },
-        s3: (region) => new s3_1.default({
+        s3: (region) => new client_s3_1.S3({
             region,
-            apiVersion: '2006-03-01',
             credentials,
-            s3ForcePathStyle: true,
-            signatureVersion: 'v4'
+            forcePathStyle: true
         })
     };
 };

package/dist/services/index.d.ts CHANGED Viewed

@@ -114,11 +114,15 @@ export declare const services: {
         }>;
     };
     aws: () => {
-        lambda: (region: string) => import("aws-sdk").Lambda & {
-            Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
-            InvokeAsync: import("aws-sdk").Lambda["invokeAsync"];
+        lambda: (region: string) => import("@aws-sdk/client-lambda/dist-types").Lambda & {
+            Invoke: (params: import("@aws-sdk/client-lambda/dist-types").InvokeCommandInput) => Promise<Omit<import("@aws-sdk/client-lambda/dist-types").InvokeCommandOutput, "Payload"> & {
+                Payload: {
+                    text: () => string | undefined;
+                };
+            }>;
+            InvokeAsync: (params: import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandInput) => Promise<import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandOutput>;
         };
-        s3: (region: string) => import("aws-sdk").S3;
+        s3: (region: string) => import("@aws-sdk/client-s3/dist-types").S3;
     };
     auth: import("./auth/model").AuthServiceType;
     'mongodb-atlas': import("./mongodb-atlas/model").MongodbAtlasFunction;

package/dist/services/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAMqT~~,~~GAAc;;;;;;;CADvV,~~CAAA"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKpB,CAAA"}

package/dist/utils/context/helpers.d.ts CHANGED Viewed

@@ -155,11 +155,15 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     context: object;
                 }>;
             } | {
-                lambda: (region: string) => import("aws-sdk").Lambda & {
-                    Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
-                    InvokeAsync: import("aws-sdk").Lambda["invokeAsync"];
+                lambda: (region: string) => import("@aws-sdk/client-lambda/dist-types").Lambda & {
+                    Invoke: (params: import("@aws-sdk/client-lambda/dist-types").InvokeCommandInput) => Promise<Omit<import("@aws-sdk/client-lambda/dist-types").InvokeCommandOutput, "Payload"> & {
+                        Payload: {
+                            text: () => string | undefined;
+                        };
+                    }>;
+                    InvokeAsync: (params: import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandInput) => Promise<import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandOutput>;
                 };
-                s3: (region: string) => import("aws-sdk").S3;
+                s3: (region: string) => import("@aws-sdk/client-s3/dist-types").S3;
             } | {
                 emailPasswordAuth: {
                     registerUser: ReturnType<import("../../shared/models/handleUserRegistration.model").HandleUserRegistration>;
@@ -284,11 +288,15 @@ export declare const generateContextData: ({ user, services, app, rules, current
                 context: object;
             }>;
         } | {
-            lambda: (region: string) => import("aws-sdk").Lambda & {
-                Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
-                InvokeAsync: import("aws-sdk").Lambda["invokeAsync"];
+            lambda: (region: string) => import("@aws-sdk/client-lambda/dist-types").Lambda & {
+                Invoke: (params: import("@aws-sdk/client-lambda/dist-types").InvokeCommandInput) => Promise<Omit<import("@aws-sdk/client-lambda/dist-types").InvokeCommandOutput, "Payload"> & {
+                    Payload: {
+                        text: () => string | undefined;
+                    };
+                }>;
+                InvokeAsync: (params: import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandInput) => Promise<import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandOutput>;
             };
-            s3: (region: string) => import("aws-sdk").S3;
+            s3: (region: string) => import("@aws-sdk/client-s3/dist-types").S3;
         } | {
             emailPasswordAuth: {
                 registerUser: ReturnType<import("../../shared/models/handleUserRegistration.model").HandleUserRegistration>;
@@ -412,11 +420,15 @@ export declare const generateContextData: ({ user, services, app, rules, current
                 context: object;
             }>;
         } | {
-            lambda: (region: string) => import("aws-sdk").Lambda & {
-                Invoke: (...args: Parameters<import("aws-sdk").Lambda["invoke"]>) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/lambda").InvocationResponse, import("aws-sdk").AWSError>>;
-                InvokeAsync: import("aws-sdk").Lambda["invokeAsync"];
+            lambda: (region: string) => import("@aws-sdk/client-lambda/dist-types").Lambda & {
+                Invoke: (params: import("@aws-sdk/client-lambda/dist-types").InvokeCommandInput) => Promise<Omit<import("@aws-sdk/client-lambda/dist-types").InvokeCommandOutput, "Payload"> & {
+                    Payload: {
+                        text: () => string | undefined;
+                    };
+                }>;
+                InvokeAsync: (params: import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandInput) => Promise<import("@aws-sdk/client-lambda/dist-types").InvokeAsyncCommandOutput>;
             };
-            s3: (region: string) => import("aws-sdk").S3;
+            s3: (region: string) => import("@aws-sdk/client-s3/dist-types").S3;
         } | {
             emailPasswordAuth: {
                 registerUser: ReturnType<import("../../shared/models/handleUserRegistration.model").HandleUserRegistration>;

package/dist/utils/context/helpers.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,0FASjC,yBAAyB;;;;uBAqBP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;+BArCU,MAAM,OAAO,QAAQ~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAZP~~,GAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAF2C,GAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAF2C,GAE3C;;;;;;;;;;4BAuDkB,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAerE,CAAA"}
1	+ {"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,0FASjC,yBAAyB;;;;uBAqBP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;+BArCU,MAAM,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA6ChC,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAerE,CAAA"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@flowerforce/flowerbase",
-  "version": "1.4.2-beta.2",
+  "version": "1.4.2-beta.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,8 @@
     "@fastify/mongodb": "^9.0.1",
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
-    "aws-sdk": "^2.1692.0",
+    "@aws-sdk/client-lambda": "^3.974.0",
+    "@aws-sdk/client-s3": "^3.974.0",
     "bson": "^6.8.0",
     "dotenv": "^16.4.7",
     "fastify": "^5.0.0",

package/src/auth/__tests__/controller.test.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import { authController } from '../controller'
+jest.mock('../../constants', () => ({
+  AUTH_CONFIG: {
+    authCollection: 'auth_users',
+    refreshTokensCollection: 'refresh_tokens',
+    userCollection: 'users',
+    user_id_field: 'id'
+  },
+  DB_NAME: 'test-db',
+  DEFAULT_CONFIG: {
+    REFRESH_TOKEN_TTL_DAYS: 1
+  }
+}))
+describe('authController', () => {
+  it('creates a unique email index on the auth collection', async () => {
+    const authCollection = {
+      createIndex: jest.fn().mockResolvedValue('ok')
+    }
+    const refreshCollection = {
+      createIndex: jest.fn().mockResolvedValue('ok')
+    }
+    const db = {
+      collection: jest.fn((name: string) => {
+        if (name === 'auth_users') {
+          return authCollection
+        }
+        if (name === 'refresh_tokens') {
+          return refreshCollection
+        }
+        return { createIndex: jest.fn().mockResolvedValue('ok') }
+      })
+    }
+    const app = {
+      mongo: { client: { db: jest.fn().mockReturnValue(db) } },
+      addHook: jest.fn(),
+      get: jest.fn(),
+      post: jest.fn(),
+      delete: jest.fn(),
+      jwtAuthentication: jest.fn()
+    }
+    await authController(app as unknown as never)
+    expect(authCollection.createIndex).toHaveBeenCalledWith(
+      { email: 1 },
+      { unique: true }
+    )
+  })
+})

package/src/auth/controller.ts CHANGED Viewed

@@ -27,6 +27,17 @@ export async function authController(app: FastifyInstance) {
     console.error('Failed to ensure refresh token TTL index', error)
   }
+  try {
+    await db.collection(authCollection).createIndex(
+      { email: 1 },
+      {
+        unique: true
+      }
+    )
+  } catch (error) {
+    console.error('Failed to ensure auth email unique index', error)
+  }
   app.addHook(HANDLER_TYPE, app.jwtAuthentication)
   /**

package/src/auth/providers/anon-user/__tests__/controller.test.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import { anonUserController } from '../controller'
+import { PROVIDER } from '../../../../shared/models/handleUserRegistration.model'
+jest.mock('../../../../constants', () => ({
+  AUTH_CONFIG: {
+    authCollection: 'auth_users',
+    refreshTokensCollection: 'refresh_tokens',
+    providers: {
+      'anon-user': { disabled: false }
+    }
+  },
+  DB_NAME: 'test-db',
+  DEFAULT_CONFIG: {
+    REFRESH_TOKEN_TTL_DAYS: 1,
+    ANON_USER_TTL_SECONDS: 3600
+  }
+}))
+describe('anonUserController', () => {
+  it('inserts anon users with a generated email', async () => {
+    let insertedDoc: Record<string, unknown> | undefined
+    const authCollection = {
+      createIndex: jest.fn().mockResolvedValue('ok'),
+      insertOne: jest.fn(async (doc: Record<string, unknown>) => {
+        insertedDoc = doc
+        return { insertedId: doc._id }
+      })
+    }
+    const refreshCollection = {
+      insertOne: jest.fn().mockResolvedValue({})
+    }
+    const db = {
+      collection: jest.fn((name: string) => {
+        if (name === 'auth_users') {
+          return authCollection
+        }
+        if (name === 'refresh_tokens') {
+          return refreshCollection
+        }
+        return authCollection
+      })
+    }
+    let loginHandler: ((...args: unknown[]) => unknown) | undefined
+    const app = {
+      mongo: { client: { db: jest.fn().mockReturnValue(db) } },
+      post: jest.fn((path: string, handler: (...args: unknown[]) => unknown) => {
+        loginHandler = handler
+      })
+    }
+    await anonUserController(app as unknown as never)
+    const context = {
+      createRefreshToken: jest.fn(() => 'refresh'),
+      createAccessToken: jest.fn(() => 'access')
+    }
+    await (loginHandler as (...args: unknown[]) => Promise<unknown>).call(context, {})
+    const doc = insertedDoc as {
+      _id: { toString: () => string }
+      email: string
+      identities: Array<{
+        id?: string
+        provider_id?: string
+        provider_type?: string
+        provider_data?: Record<string, unknown>
+      }>
+    }
+    expect(doc.email).toBe(`anon-${doc._id.toString()}@users.invalid`)
+    expect(doc.identities[0]).toEqual(
+      expect.objectContaining({
+        id: doc._id.toString(),
+        provider_id: doc._id.toString(),
+        provider_type: PROVIDER.ANON_USER,
+        provider_data: {}
+      })
+    )
+  })
+})

package/src/auth/providers/anon-user/controller.ts CHANGED Viewed

@@ -1,7 +1,8 @@
+import { ObjectId } from 'bson'
 import { FastifyInstance } from 'fastify'
 import { AUTH_CONFIG, DB_NAME, DEFAULT_CONFIG } from '../../../constants'
-import { hashToken } from '../../../utils/crypto'
 import { PROVIDER } from '../../../shared/models/handleUserRegistration.model'
+import { hashToken } from '../../../utils/crypto'
 import { AUTH_ENDPOINTS } from '../../utils'
 import { LoginDto } from './dtos'
@@ -37,35 +38,24 @@ export async function anonUserController(app: FastifyInstance) {
       }
       const now = new Date()
-      const insertResult = await db.collection(authCollection!).insertOne({
+      const userId = new ObjectId()
+      const anonEmail = `anon-${userId.toString()}@users.invalid`
+      await db.collection(authCollection!).insertOne({
+        _id: userId,
+        email: anonEmail,
         status: 'confirmed',
         createdAt: now,
         custom_data: {},
         identities: [
           {
+            id: userId.toString(),
+            provider_id: userId.toString(),
             provider_type: PROVIDER.ANON_USER,
             provider_data: {}
           }
         ]
       })
-      const userId = insertResult.insertedId
-      await db.collection(authCollection!).updateOne(
-        { _id: userId },
-        {
-          $set: {
-            identities: [
-              {
-                id: userId.toString(),
-                provider_id: userId.toString(),
-                provider_type: PROVIDER.ANON_USER,
-                provider_data: {}
-              }
-            ]
-          }
-        }
-      )
       const currentUserData = {
         _id: userId,
         user_data: {}

package/src/auth/utils.ts CHANGED Viewed

@@ -11,10 +11,10 @@ export const LOGIN_SCHEMA = {
       username: {
         type: 'string',
         pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-        minLength: 3,
+        minLength: 5,
         maxLength: 254
       },
-      password: { type: 'string', minLength: 8, maxLength: 128 }
+      password: { type: 'string', minLength: 6, maxLength: 128 }
     },
     required: ['username', 'password']
   }
@@ -27,7 +27,7 @@ export const RESET_SEND_SCHEMA = {
       email: {
         type: 'string',
         pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-        minLength: 3,
+        minLength: 5,
         maxLength: 254
       }
     },
@@ -42,10 +42,10 @@ export const RESET_CALL_SCHEMA = {
       email: {
         type: 'string',
         pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-        minLength: 3,
+        minLength: 5,
         maxLength: 254
       },
-      password: { type: 'string', minLength: 8, maxLength: 128 },
+      password: { type: 'string', minLength: 6, maxLength: 128 },
       arguments: { type: 'array' }
     },
     required: ['email', 'password']
@@ -56,7 +56,7 @@ export const CONFIRM_RESET_SCHEMA = {
   body: {
     type: 'object',
     properties: {
-      password: { type: 'string', minLength: 8, maxLength: 128 },
+      password: { type: 'string', minLength: 6, maxLength: 128 },
       token: { type: 'string' },
       tokenId: { type: 'string' }
     },
@@ -84,10 +84,10 @@ export const REGISTRATION_SCHEMA = {
       email: {
         type: 'string',
         pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$',
-        minLength: 3,
+        minLength: 5,
         maxLength: 254
       },
-      password: { type: 'string', minLength: 8, maxLength: 128 }
+      password: { type: 'string', minLength: 6, maxLength: 128 }
     },
     required: ['email', 'password']
   }

package/src/services/aws/index.ts CHANGED Viewed

@@ -1,16 +1,37 @@
-import { AWSError, Credentials } from 'aws-sdk'
-import Lambda from 'aws-sdk/clients/lambda'
-import S3 from 'aws-sdk/clients/s3'
-import { PromiseResult } from 'aws-sdk/lib/request'
+import {
+  InvokeAsyncCommand,
+  InvokeAsyncCommandInput,
+  InvokeAsyncCommandOutput,
+  InvokeCommand,
+  InvokeCommandInput,
+  InvokeCommandOutput,
+  Lambda
+} from '@aws-sdk/client-lambda'
+import { S3 } from '@aws-sdk/client-s3'
 import { S3_CONFIG } from '../../constants'
+type LambdaInvokeResponse = Omit<InvokeCommandOutput, 'Payload'> & {
+  Payload: {
+    text: () => string | undefined
+  }
+}
-const Aws = () => {
+const decodePayload = (payload?: Uint8Array): string | undefined => {
+  if (!payload) {
+    return undefined
+  }
-  const credentials = {
-    accessKeyId: S3_CONFIG.ACCESS_KEY_ID,
-    secretAccessKey: S3_CONFIG.SECRET_ACCESS_KEY,
-  } as Credentials
+  return Buffer.from(payload).toString('utf-8')
+}
+const Aws = () => {
+  const credentials =
+    S3_CONFIG.ACCESS_KEY_ID && S3_CONFIG.SECRET_ACCESS_KEY
+      ? {
+        accessKeyId: S3_CONFIG.ACCESS_KEY_ID,
+        secretAccessKey: S3_CONFIG.SECRET_ACCESS_KEY
+      }
+      : undefined
   return {
     lambda: (region: string) => {
@@ -18,30 +39,36 @@ const Aws = () => {
         region: region,
         credentials
       }) as Lambda & {
-        Invoke: (
-          ...args: Parameters<Lambda['invoke']>
-        ) => Promise<PromiseResult<Lambda.InvocationResponse, AWSError>>
-        InvokeAsync: Lambda['invokeAsync']
+        Invoke: (params: InvokeCommandInput) => Promise<LambdaInvokeResponse>
+        InvokeAsync: (params: InvokeAsyncCommandInput) => Promise<InvokeAsyncCommandOutput>
       }
-      lambda.Invoke = async (...args: Parameters<Lambda['invoke']>) => {
-        const res = await lambda.invoke(...args).promise()
+      lambda.Invoke = async (params: InvokeCommandInput): Promise<LambdaInvokeResponse> => {
+        const res = await lambda.send(new InvokeCommand(params))
         return {
           ...res,
           Payload: {
-            text: () => res.Payload
+            text: () => decodePayload(res.Payload)
           }
         }
       }
-      lambda.InvokeAsync = lambda.invokeAsync
+      const invokeAsync = async (
+        params: InvokeAsyncCommandInput
+      ): Promise<InvokeAsyncCommandOutput> => {
+        return lambda.send(new InvokeAsyncCommand(params))
+      }
+      lambda.InvokeAsync = invokeAsync
+      lambda.invokeAsync = invokeAsync
       return lambda
     },
     s3: (region: string) =>
       new S3({
         region,
-        apiVersion: '2006-03-01',
         credentials,
-        s3ForcePathStyle: true,
-        signatureVersion: 'v4'
+        forcePathStyle: true
       })
   }
 }