backend-manager 5.9.7 → 5.9.9

package/templates/database.rules.json

@@ -0,0 +1,83 @@
+{
+  "rules": {
+    ///---backend-manager---///
+    ///---version=0.0.0---///
+
+    // Sessions rules
+    "sessions": {
+      ".read": false,
+      ".write": false,
+			"$room": {
+        ".read": "
+        	(auth.uid != null && query.equalTo == auth.uid)
+        ",
+        ".write": false,
+        ".indexOn": ["uid"],
+        "$id": {
+          ".read": "
+          	// Allowed if user is authenticated AND is the owner of the doc
+          	(auth != null && auth.uid == data.child('uid').val())
+            // Allowed if uid is equal to the doc id [LEGACY FOR SOMIIBO]
+            || (auth != null && auth.uid == $id)
+          	// Allowed if user is not authenticated AND is the doc has no owner
+          	|| (auth == null && (data.child('uid').val() == ''))
+          ",
+          ".write": "
+          	// Allowed if the user is authenticated AND is the owner of the existing doc
+          	(auth != null && auth.uid == data.child('uid').val())
+          	// Allowed if the user is authenticated AND is the owner of the new doc
+          	|| (auth != null && auth.uid == newData.child('uid').val())
+            // Allowed if the user is authenticated AND is the owner of the existing doc
+          	|| (auth != null && auth.uid == data.child('uid').val())
+            // Allowed if uid is equal to the doc id [LEGACY FOR SOMIIBO]
+            || (auth != null && auth.uid == $id)
+            // Allowed if the existing doc has no owner
+          	|| (data.child('uid').val() == '')
+          	// Allowed if the new doc has no owner
+          	|| (newData.child('uid').val() == '')
+            // Allowed if it's a delete
+          	|| (!newData.exists())
+          ",
+      	}
+      }
+    },
+    "gatherings": {
+      ".read": false,
+      ".write": false,
+			"$room": {
+        ".read": "
+        	(auth.uid != null && query.equalTo == auth.uid)
+        ",
+        ".write": false,
+        ".indexOn": ["uid"],
+        "$id": {
+          ".read": "
+          	// Allowed if user is authenticated AND is the owner of the doc
+          	(auth != null && auth.uid == data.child('uid').val())
+            // Allowed if uid is equal to the doc id [LEGACY FOR SOMIIBO]
+            || (auth != null && auth.uid == $id)
+          	// Allowed if user is not authenticated AND is the doc has no owner
+          	|| (auth == null && (data.child('uid').val() == ''))
+          ",
+          ".write": "
+          	// Allowed if the user is authenticated AND is the owner of the existing doc
+          	(auth != null && auth.uid == data.child('uid').val())
+          	// Allowed if the user is authenticated AND is the owner of the new doc
+          	|| (auth != null && auth.uid == newData.child('uid').val())
+            // Allowed if the user is authenticated AND is the owner of the existing doc
+          	|| (auth != null && auth.uid == data.child('uid').val())
+            // Allowed if uid is equal to the doc id [LEGACY FOR SOMIIBO]
+            || (auth != null && auth.uid == $id)
+            // Allowed if the existing doc has no owner
+          	|| (data.child('uid').val() == '')
+          	// Allowed if the new doc has no owner
+          	|| (newData.child('uid').val() == '')
+            // Allowed if it's a delete
+          	|| (!newData.exists())
+          ",
+      	}
+      }
+    },
+    ///---------end---------///
+  }
+}

package/templates/firebase.json

@@ -0,0 +1,66 @@
+{
+  "hosting": {
+    "public": "public",
+    "ignore": [
+      "firebase.json",
+      "**/.*",
+      "**/node_modules/**"
+    ],
+    "rewrites": [
+      {
+        "source": "{/backend-manager,/backend-manager/**,/mcp,/mcp/**,/.well-known/oauth-protected-resource,/.well-known/oauth-authorization-server,/authorize,/token,/register}",
+        "function": "bm_api"
+      }
+    ]
+  },
+  "functions": [
+    {
+      "source": "functions",
+      "codebase": "default",
+      "ignore": [
+        "node_modules",
+        ".git",
+        "firebase-debug.log",
+        "firebase-debug.*.log"
+      ]
+    }
+  ],
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  },
+  "database": {
+    "rules": "database.rules.json"
+  },
+  "storage": {
+    "rules": "storage.rules"
+  },
+  "emulators": {
+    "auth": {
+      "port": 9099
+    },
+    "functions": {
+      "port": 5001
+    },
+    "firestore": {
+      "port": 8080
+    },
+    "database": {
+      "port": 9000
+    },
+    "hosting": {
+      "port": 5002
+    },
+    "storage": {
+      "port": 9199
+    },
+    "ui": {
+      "enabled": true,
+      "port": 4050
+    },
+    "pubsub": {
+      "port": 8085
+    },
+    "singleProjectMode": true
+  }
+}

package/templates/firestore.indexes.json

@@ -0,0 +1,4 @@
+{
+  "indexes": [],
+  "fieldOverrides": []
+}

package/templates/firestore.rules

@@ -0,0 +1,112 @@
+rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Custom rules
+    // ...
+
+    ///---backend-manager---///
+    ///---version=0.0.0---///
+    // Lock by default
+    match /{document=**} {
+      allow read, write: if isAdmin();
+    }
+
+    // Protect user account data
+    match /users/{uid} {
+      allow read: if belongsTo(uid);
+      allow write: if belongsTo(uid) && !isWritingProtectedUserField();
+    }
+
+    // Protect notification data
+    match /notifications/{token} {
+      allow read: if resource == null || existingData().token == token || belongsTo(existingData().owner);
+      allow update: if existingData().token == token;
+      allow create: if true;
+    }
+
+    // Protect abandoned cart data
+    match /payments-carts/{uid} {
+      allow create, update: if belongsTo(uid)
+        && incomingData().owner == uid
+        && incomingData().status == 'pending';
+      allow read: if belongsTo(uid);
+    }
+
+    // Auth functions
+    function authEmail() {
+      return request.auth.token.email;
+    }
+    function authUid() {
+      return request.auth.uid;
+    }
+    function isAuthenticated() {
+      return request.auth != null;
+    }
+    function belongsTo(identity) {
+      return isAuthenticated() && (authUid() == identity || authEmail() == identity);
+      // eventually include a check for (existingData().owner == identity)...(in case its a doc owned by a user that's not actually user doc)
+    }
+
+    function getRoles() {
+      return get(/databases/$(database)/documents/users/$(request.auth.uid)).data.roles;
+    }
+    function getVerifications() {
+      return get(/databases/$(database)/documents/users/$(request.auth.uid)).data.verifications;
+    }
+    function isAdmin() {
+      return getRoles().admin == true;
+    }
+    function emailVerified() {
+      return getVerifications().email == true;
+    }
+
+    function isWritingProtectedUserField() {
+      return isWritingField('auth')
+        || isWritingField('roles')
+        || isWritingField('flags')
+        || isWritingField('plan') // TODO: REMOVE THIS WHEN ALL PROJECTS UPDATED
+        || isWritingField('subscription')
+        || isWritingField('affiliate')
+        || isWritingField('api')
+        || isWritingField('metadata')
+        || isWritingField('usage')
+        || isWritingField('consent');
+    }
+
+    function isCreatingField(field) {
+      return !(field in resource.data) && field in request.resource.data;
+    }
+
+    function isUpdatingField(field) {
+      return field in resource.data && field in request.resource.data && resource.data[field] != request.resource.data[field];
+    }
+
+    function isWritingField(field) {
+      return isCreatingField(field) || isUpdatingField(field);
+    }
+
+    // function userEmail(userId) {
+    //   return get(/databases/$(database)/documents/users/$(userId)).data.email;
+    // }
+    // Helper functions
+    // [READ] Data that exists on the Firestore document
+    function existingData() {
+      return resource.data;
+    }
+    // [WRITE] Data that is sent to a Firestore document
+    function incomingData() {
+      return request.resource.data;
+    }
+    ///--------tests--------///
+    // match /test-cases/write/admin {
+    //   allow write: if isAdmin();
+    // }
+    ///------resources------///
+    // https://fireship.io/snippets/firestore-rules-recipes/
+    // https://github.com/jaysquared/atom-firestore-grammar
+    // https://fireship.io/courses/firestore-data-modeling/models-roles/
+    // https://firebase.google.com/docs/firestore/security/test-rules-emulator
+    ///---------end---------///
+
+  }
+}

package/templates/public/404.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>404 Error Page</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
+  </head>
+
+  <body>
+    <div class="d-flex align-items-center justify-content-center vh-100">
+      <div class="text-center">
+        <h1 class="display-1 fw-bold">404</h1>
+
+        <p class="fs-3"> <span class="text-danger">Opps!</span> Page not found.</p>
+
+        <p class="lead">
+          The page you're looking for doesn't exist.
+        </p>
+
+        <a href="{url}" class="btn btn-primary">Go Home</a>
+      </div>
+    </div>
+  </body>
+</html>

package/templates/public/index.html

@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>404 Error Page</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
+  </head>
+
+  <body>
+    <div class="d-flex align-items-center justify-content-center vh-100">
+      <div class="text-center">
+        <h1 class="display-1 fw-bold">Welcome!</h1>
+
+        <p class="lead">
+          This is an internal page, please return to our main website
+        </p>
+
+        <a href="{url}" class="btn btn-primary">Go Home</a>
+      </div>
+    </div>
+  </body>
+</html>

package/templates/remoteconfig.template.json

@@ -0,0 +1 @@
+{}

package/templates/storage-lifecycle-config-1-day.json

@@ -0,0 +1,9 @@
+{
+  "rule":
+  [
+    {
+      "action": {"type": "Delete"},
+      "condition": {"age": 1}
+    }
+  ]
+}

package/templates/storage-lifecycle-config-30-days.json

@@ -0,0 +1,9 @@
+{
+  "rule":
+  [
+    {
+      "action": {"type": "Delete"},
+      "condition": {"age": 30}
+    }
+  ]
+}

package/templates/storage.rules

@@ -0,0 +1,8 @@
+rules_version = '2';
+service firebase.storage {
+  match /b/{bucket}/o {
+    match /{allPaths=**} {
+      allow read, write: if request.auth!=null;
+    }
+  }
+}

package/test/_init/accounts-validation.js

@@ -0,0 +1,58 @@
+const { TEST_ACCOUNTS } = require('../../src/test/test-accounts.js');
+
+/**
+ * Test: Account Structure Validation
+ * Verifies that all test accounts were created with the expected User helper fields
+ * This catches failures in auth:on-create before other tests run
+ */
+module.exports = {
+  description: 'Test accounts have required User structure',
+  auth: 'none',
+  timeout: 10000,
+
+  async run({ accounts, assert, firestore }) {
+    const accountIds = Object.keys(TEST_ACCOUNTS);
+
+    for (const accountId of accountIds) {
+      const account = accounts[accountId];
+
+      // Check account was fetched
+      assert.ok(account, `Account '${accountId}' should exist in accounts object`);
+      assert.ok(account.uid, `Account '${accountId}' should have uid`);
+
+      // Fetch full user doc from Firestore
+      const userDoc = await firestore.get(`users/${account.uid}`);
+
+      assert.ok(userDoc, `User doc for '${accountId}' should exist in Firestore`);
+
+      // Validate auth fields (set by on-create)
+      assert.hasProperty(userDoc, 'auth.uid', `Account '${accountId}' should have auth.uid`);
+      assert.hasProperty(userDoc, 'auth.email', `Account '${accountId}' should have auth.email`);
+
+      // Validate API fields (generated by on-create via User helper)
+      assert.hasProperty(userDoc, 'api.clientId', `Account '${accountId}' should have api.clientId`);
+      assert.hasProperty(userDoc, 'api.privateKey', `Account '${accountId}' should have api.privateKey`);
+
+      // Validate privateKey was fetched correctly
+      assert.ok(account.privateKey, `Account '${accountId}' privateKey should be fetched`);
+      assert.equal(
+        account.privateKey,
+        userDoc.api.privateKey,
+        `Account '${accountId}' fetched privateKey should match Firestore`
+      );
+
+      // Validate affiliate code (generated by on-create via User helper)
+      assert.hasProperty(userDoc, 'affiliate.code', `Account '${accountId}' should have affiliate.code`);
+
+      // Validate metadata.created (set by on-create via User helper)
+      assert.hasProperty(userDoc, 'metadata.created.timestamp', `Account '${accountId}' should have metadata.created.timestamp`);
+      assert.hasProperty(userDoc, 'metadata.created.timestampUNIX', `Account '${accountId}' should have metadata.created.timestampUNIX`);
+
+      // Validate subscription fields (merged from test account properties)
+      assert.hasProperty(userDoc, 'subscription.product.id', `Account '${accountId}' should have subscription.product.id`);
+      assert.hasProperty(userDoc, 'subscription.status', `Account '${accountId}' should have subscription.status`);
+    }
+
+    return { success: true };
+  },
+};

package/test/_legacy/ai/index.js

@@ -0,0 +1,231 @@
+const assert = require('assert');
+const Manager = require('../../src/manager/index.js');
+
+describe('AI Library Tests', function() {
+  let manager;
+  let assistant;
+  let ai;
+
+  before(function() {
+    manager = new Manager();
+    manager.init(exports, {
+      projectType: 'custom',
+      setupServer: false,
+      initialize: false,
+      backendManagerConfigPath: 'templates/backend-manager-config.json',
+    });
+    assistant = manager.assistant;
+    ai = new (require('../../src/manager/libraries/openai'))(assistant, process.env.OPENAI_API_KEY);
+  });
+
+  if (!process.env.OPENAI_API_KEY) {
+    throw new Error('OPENAI_API_KEY is not set. Please set it in your environment variables.');
+  }
+
+  describe('Simple AI Message Test', function() {
+    it('should respond with "Hi!" when asked to say hi', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        prompt: { content: 'You are helping test an implementation. Please respond with "Hi!" and nothing else.' },
+        message: { content: 'Hi there friend!' },
+      });
+
+      assert(response);
+      assert(response.content);
+      assert.strictEqual(response.content.trim(), 'Hi!');
+    });
+
+    it('should analyze an image and respond with "cat"', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        prompt: { content: 'You are a helpful assistant that describes images. Please answer in ONE WORD.' },
+        message: {
+          content: 'What animal is this?',
+          attachments: [
+            {
+              type: 'image',
+              content: `${__dirname}/test.jpg`,
+            }
+          ]
+        },
+      });
+
+      assert(response);
+      assert(response.content);
+      assert.strictEqual(response.content.trim().toLowerCase(), 'cat');
+    });
+
+    it('should analyze a PDF file and respond with "42"', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        prompt: { content: 'You are a helpful assistant that analyzes documents. Please answer in ONE WORD.' },
+        message: {
+          content: 'What is the answer (numerical form)?',
+          attachments: [
+            {
+              type: 'file',
+              content: `${__dirname}/test.pdf`,
+              filename: 'test.pdf'
+            }
+          ]
+        },
+      });
+
+      assert(response);
+      assert.strictEqual(response.content.trim().toLowerCase(), '42');
+    });
+
+    it('should analyze a remote image URL and respond with "cat"', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        prompt: { content: 'You are a helpful assistant that describes images. Please answer in ONE WORD.' },
+        message: {
+          content: 'What animal is this?',
+          attachments: [
+            {
+              type: 'image',
+              content: 'https://raw.githubusercontent.com/ITW-Creative-Works/backend-manager/master/test/ai/test.jpg',
+            }
+          ]
+        },
+      });
+
+      assert(response);
+      assert(response.content);
+      assert.strictEqual(response.content.trim().toLowerCase(), 'cat');
+    });
+
+    it('should analyze a remote PDF URL and respond with "42"', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        prompt: { content: 'You are a helpful assistant that analyzes documents. Please answer in ONE WORD.' },
+        message: {
+          content: 'What is the answer (numerical form)?',
+          attachments: [
+            {
+              type: 'file',
+              content: 'https://raw.githubusercontent.com/ITW-Creative-Works/backend-manager/master/test/ai/test.pdf',
+              filename: 'test.pdf'
+            }
+          ]
+        },
+      });
+
+      assert(response);
+      assert.strictEqual(response.content.trim().toLowerCase(), '42');
+    });
+
+    it('should return JSON when response format is set to json', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        response: 'json',
+        prompt: { content: 'You are a helpful assistant that returns structured data in JSON format.' },
+        message: { content: 'Give me information about a cat in JSON format with fields: name, age, color.' },
+      });
+
+      assert(response);
+      assert(response.content);
+      assert(typeof response.content === 'object');
+      assert(response.content.name);
+      assert(response.content.age);
+      assert(response.content.color);
+    });
+
+    it('should return data matching schema when schema is provided', async function() {
+      this.timeout(30000);
+
+      const schema = {
+        type: 'object',
+        properties: {
+          animal: {
+            type: 'string',
+            description: 'The type of animal'
+          },
+          characteristics: {
+            type: 'array',
+            items: {
+              type: 'string'
+            },
+            description: 'List of characteristics'
+          },
+          habitat: {
+            type: 'string',
+            description: 'Where the animal lives'
+          }
+        },
+        required: ['animal', 'characteristics', 'habitat'],
+        additionalProperties: false
+      };
+
+      const response = await ai.request({
+        // log: true,
+        response: 'json',
+        schema: schema,
+        prompt: { content: 'You are a helpful assistant that provides animal information.' },
+        message: { content: 'Tell me about a lion.' },
+      });
+
+      assert(response);
+      assert(response.content);
+      assert(typeof response.content === 'object');
+      assert.strictEqual(typeof response.content.animal, 'string');
+      assert(Array.isArray(response.content.characteristics));
+      assert.strictEqual(typeof response.content.habitat, 'string');
+      assert(response.content.animal.toLowerCase().includes('lion'));
+    });
+
+    it('should moderate content and return moderation results', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        moderate: true,
+        prompt: { content: 'You are a helpful assistant.' },
+        message: { content: 'This is a completely normal and appropriate message about cats.' },
+      });
+
+      assert(response);
+      assert(response.content);
+      assert(response.moderation);
+      assert(typeof response.moderation.flagged === 'boolean');
+      assert.strictEqual(response.moderation.flagged, false);
+    });
+
+    it('should moderate content with image attachment', async function() {
+      this.timeout(30000);
+
+      const response = await ai.request({
+        // log: true,
+        moderate: true,
+        prompt: { content: 'You are a helpful assistant.' },
+        message: {
+          content: 'Here is an image of a cat.',
+          attachments: [
+            {
+              type: 'image',
+              content: `${__dirname}/test.jpg`,
+            }
+          ]
+        },
+      });
+
+      assert(response);
+      assert(response.content);
+      assert(response.moderation);
+      assert(typeof response.moderation.flagged === 'boolean');
+      assert.strictEqual(response.moderation.flagged, false);
+    });
+  });
+});

package/test/_legacy/index.js

@@ -0,0 +1,31 @@
+const package = require('../package.json');
+const assert = require('assert');
+
+beforeEach(() => {
+});
+
+before(() => {
+});
+
+after(() => {
+});
+
+/*
+ * ============
+ *  Test Cases
+ * ============
+ */
+describe(`${package.name}`, () => {
+  describe('.dependencies()', () => {
+    Object.keys(package.dependencies).forEach((dependency) => {
+      it(`should load ${dependency}`, () => {
+        try {
+          const dep = require(dependency);
+          assert.ok(dep);
+        } catch (e) {
+          assert.fail(`Failed to load ${dependency}: ${e.message}`);
+        }
+      });
+    });
+  });
+})