@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/__tests__/e2e/helpers/testGraphQLServer.js

@@ -0,0 +1,197 @@
+import { buildSchema, graphql } from 'graphql';
+import http from 'http';
+/**
+ * E2E Test GraphQL Server
+ * Mocks only the database/resolver layer while keeping real GraphQL execution
+ * Uses minimal HTTP + graphql-core
+ */ const typeDefs = `
+  type Query {
+    health: String!
+  }
+
+  type Mutation {
+    users: UsersMutation!
+  }
+
+  type UsersMutation {
+    signIn(user: UserInput!, expires: Int): Session
+    addUser(user: UserInput!): User
+    refreshSession(token: String!, expires: Int): Session
+  }
+
+  type Session {
+    token: String!
+    expires: Int
+    issued: Int
+    userId: String!
+    username: String!
+  }
+
+  type User {
+    userId: String!
+    username: String!
+    email: String
+  }
+
+  input UserInput {
+    username: String!
+    email: String
+    password: String!
+  }
+`;
+// Mock database
+export const MOCK_USER = {
+    userId: 'user-123',
+    username: 'testuser',
+    email: 'test@example.com',
+    password: 'password123'
+};
+export const MOCK_SESSION = {
+    token: 'auth-token-xyz-123',
+    expires: Math.floor(Date.now() / 1000) + 86400,
+    issued: Math.floor(Date.now() / 1000),
+    userId: MOCK_USER.userId,
+    username: MOCK_USER.username
+};
+/**
+ * Start test GraphQL server
+ */ export const startTestServer = async (port = 3001)=>{
+    const schema = buildSchema(typeDefs);
+    const server = http.createServer(async (req, res)=>{
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        res.setHeader('Content-Type', 'application/json');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (req.url === '/graphql' && req.method === 'POST') {
+            // Handle GraphQL requests
+            let body = '';
+            req.on('data', (chunk)=>{
+                body += chunk.toString();
+            });
+            req.on('end', async ()=>{
+                try {
+                    const { query, variables } = JSON.parse(body);
+                    console.log('GraphQL request received', {
+                        query,
+                        variables
+                    });
+                    // Create root value with proper resolver structure
+                    const rootValue = {
+                        health: ()=>'ok',
+                        users: (_parent, args, context, info)=>{
+                            // Return an object that resolves the UsersMutation fields
+                            return {
+                                signIn: (args)=>{
+                                    const { expires, user = {} } = args;
+                                    const { password, username } = user;
+                                    if (username === MOCK_USER.username && password === MOCK_USER.password) {
+                                        return {
+                                            token: MOCK_SESSION.token,
+                                            expires: expires || MOCK_SESSION.expires,
+                                            issued: MOCK_SESSION.issued,
+                                            userId: MOCK_USER.userId,
+                                            username: MOCK_USER.username
+                                        };
+                                    }
+                                    throw new Error('Invalid credentials');
+                                },
+                                addUser: (args)=>{
+                                    const { user } = args;
+                                    return {
+                                        userId: `user-${Date.now()}`,
+                                        username: user.username,
+                                        email: user.email
+                                    };
+                                },
+                                refreshSession: (args)=>{
+                                    const { token, expires } = args;
+                                    if (token === MOCK_SESSION.token) {
+                                        return {
+                                            token: MOCK_SESSION.token,
+                                            expires: expires || MOCK_SESSION.expires,
+                                            issued: Math.floor(Date.now() / 1000),
+                                            userId: MOCK_USER.userId,
+                                            username: MOCK_USER.username
+                                        };
+                                    }
+                                    throw new Error('Invalid token');
+                                }
+                            };
+                        }
+                    };
+                    const result = await graphql({
+                        schema,
+                        source: query,
+                        rootValue,
+                        variableValues: variables || {}
+                    });
+                    console.log('GraphQL result', JSON.stringify(result, null, 2));
+                    res.writeHead(200);
+                    res.end(JSON.stringify(result));
+                } catch (error) {
+                    console.error('GraphQL server error', error);
+                    res.writeHead(500);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    res.end(JSON.stringify({
+                        errors: [
+                            {
+                                message: errorMessage
+                            }
+                        ]
+                    }));
+                }
+            });
+        } else if (req.url === '/upload' && req.method === 'POST') {
+            // Handle file upload requests
+            console.log('Upload request received');
+            // Mock successful upload response
+            res.writeHead(200);
+            res.end(JSON.stringify({
+                data: {
+                    success: true,
+                    url: 'https://example.com/uploaded-image.jpg'
+                }
+            }));
+        } else {
+            res.writeHead(404);
+            res.end(JSON.stringify({
+                error: 'Not found'
+            }));
+        }
+    });
+    return new Promise((resolve)=>{
+        server.listen(port, ()=>{
+            console.log(`Test GraphQL server running on http://localhost:${port}/graphql`);
+            resolve({
+                server,
+                port
+            });
+        });
+    });
+};
+// Sanity check so this helper file is treated as a test module without failing
+describe('testGraphQLServer helper', ()=>{
+    it('exports startTestServer and stopTestServer', ()=>{
+        expect(typeof startTestServer).toBe('function');
+        expect(typeof stopTestServer).toBe('function');
+    });
+});
+/**
+ * Stop test server
+ */ export const stopTestServer = (server)=>{
+    return new Promise((resolve)=>{
+        server.close(resolve);
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/__tests__/e2e/helpers/testGraphQLServer.ts"],"sourcesContent":["import { buildSchema, graphql } from 'graphql';\nimport http from 'http';\n\n/**\n * E2E Test GraphQL Server\n * Mocks only the database/resolver layer while keeping real GraphQL execution\n * Uses minimal HTTP + graphql-core\n */\n\nconst typeDefs = `\n  type Query {\n    health: String!\n  }\n\n  type Mutation {\n    users: UsersMutation!\n  }\n\n  type UsersMutation {\n    signIn(user: UserInput!, expires: Int): Session\n    addUser(user: UserInput!): User\n    refreshSession(token: String!, expires: Int): Session\n  }\n\n  type Session {\n    token: String!\n    expires: Int\n    issued: Int\n    userId: String!\n    username: String!\n  }\n\n  type User {\n    userId: String!\n    username: String!\n    email: String\n  }\n\n  input UserInput {\n    username: String!\n    email: String\n    password: String!\n  }\n`;\n\n// Mock database\nexport const MOCK_USER = {\n  userId: 'user-123',\n  username: 'testuser',\n  email: 'test@example.com',\n  password: 'password123'\n};\n\nexport const MOCK_SESSION = {\n  token: 'auth-token-xyz-123',\n  expires: Math.floor(Date.now() / 1000) + 86400,\n  issued: Math.floor(Date.now() / 1000),\n  userId: MOCK_USER.userId,\n  username: MOCK_USER.username\n};\n\n/**\n * Start test GraphQL server\n */\nexport const startTestServer = async (port = 3001) => {\n  const schema = buildSchema(typeDefs);\n\n  const server = http.createServer(async (req, res) => {\n    res.setHeader('Access-Control-Allow-Origin', '*');\n    res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');\n    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');\n    res.setHeader('Content-Type', 'application/json');\n\n    if (req.method === 'OPTIONS') {\n      res.writeHead(200);\n      res.end();\n      return;\n    }\n\n    if (req.method === 'OPTIONS') {\n      res.writeHead(200);\n      res.end();\n      return;\n    }\n\n    if (req.url === '/graphql' && req.method === 'POST') {\n      // Handle GraphQL requests\n      let body = '';\n      req.on('data', chunk => {\n        body += chunk.toString();\n      });\n\n      req.on('end', async () => {\n        try {\n          const {query, variables} = JSON.parse(body);\n          console.log('GraphQL request received', {query, variables});\n\n          // Create root value with proper resolver structure\n          const rootValue = {\n            health: () => 'ok',\n            users: (_parent, args, context, info) => {\n              // Return an object that resolves the UsersMutation fields\n              return {\n                signIn: (args) => {\n                  const {expires, user = {}} = args;\n                  const {password, username} = user;\n\n                  if (username === MOCK_USER.username && password === MOCK_USER.password) {\n                    return {\n                      token: MOCK_SESSION.token,\n                      expires: expires || MOCK_SESSION.expires,\n                      issued: MOCK_SESSION.issued,\n                      userId: MOCK_USER.userId,\n                      username: MOCK_USER.username\n                    };\n                  }\n                  throw new Error('Invalid credentials');\n                },\n                addUser: (args) => {\n                  const {user} = args;\n\n                  return {\n                    userId: `user-${Date.now()}`,\n                    username: user.username,\n                    email: user.email\n                  };\n                },\n                refreshSession: (args) => {\n                  const {token, expires} = args;\n\n                  if (token === MOCK_SESSION.token) {\n                    return {\n                      token: MOCK_SESSION.token,\n                      expires: expires || MOCK_SESSION.expires,\n                      issued: Math.floor(Date.now() / 1000),\n                      userId: MOCK_USER.userId,\n                      username: MOCK_USER.username\n                    };\n                  }\n                  throw new Error('Invalid token');\n                }\n              };\n            }\n          };\n\n          const result = await graphql({\n            schema,\n            source: query,\n            rootValue,\n            variableValues: variables || {}\n          });\n\n          console.log('GraphQL result', JSON.stringify(result, null, 2));\n\n          res.writeHead(200);\n          res.end(JSON.stringify(result));\n        } catch (error) {\n          console.error('GraphQL server error', error);\n          res.writeHead(500);\n          const errorMessage = error instanceof Error ? error.message : String(error);\n          res.end(JSON.stringify({\n            errors: [{message: errorMessage}]\n          }));\n        }\n      });\n    } else if (req.url === '/upload' && req.method === 'POST') {\n      // Handle file upload requests\n      console.log('Upload request received');\n\n      // Mock successful upload response\n      res.writeHead(200);\n      res.end(JSON.stringify({\n        data: {\n          success: true,\n          url: 'https://example.com/uploaded-image.jpg'\n        }\n      }));\n    } else {\n      res.writeHead(404);\n      res.end(JSON.stringify({error: 'Not found'}));\n    }\n  });\n\n  return new Promise((resolve) => {\n    server.listen(port, () => {\n      console.log(`Test GraphQL server running on http://localhost:${port}/graphql`);\n      resolve({server, port});\n    });\n  });\n};\n\n// Sanity check so this helper file is treated as a test module without failing\ndescribe('testGraphQLServer helper', () => {\n  it('exports startTestServer and stopTestServer', () => {\n    expect(typeof startTestServer).toBe('function');\n    expect(typeof stopTestServer).toBe('function');\n  });\n});\n\n/**\n * Stop test server\n */\nexport const stopTestServer = (server) => {\n  return new Promise((resolve) => {\n    server.close(resolve);\n  });\n};\n"],"names":["buildSchema","graphql","http","typeDefs","MOCK_USER","userId","username","email","password","MOCK_SESSION","token","expires","Math","floor","Date","now","issued","startTestServer","port","schema","server","createServer","req","res","setHeader","method","writeHead","end","url","body","on","chunk","toString","query","variables","JSON","parse","console","log","rootValue","health","users","_parent","args","context","info","signIn","user","Error","addUser","refreshSession","result","source","variableValues","stringify","error","errorMessage","message","String","errors","data","success","Promise","resolve","listen","describe","it","expect","toBe","stopTestServer","close"],"mappings":"AAAA,SAASA,WAAW,EAAEC,OAAO,QAAQ,UAAU;AAC/C,OAAOC,UAAU,OAAO;AAExB;;;;CAIC,GAED,MAAMC,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkClB,CAAC;AAED,gBAAgB;AAChB,OAAO,MAAMC,YAAY;IACvBC,QAAQ;IACRC,UAAU;IACVC,OAAO;IACPC,UAAU;AACZ,EAAE;AAEF,OAAO,MAAMC,eAAe;IAC1BC,OAAO;IACPC,SAASC,KAAKC,KAAK,CAACC,KAAKC,GAAG,KAAK,QAAQ;IACzCC,QAAQJ,KAAKC,KAAK,CAACC,KAAKC,GAAG,KAAK;IAChCV,QAAQD,UAAUC,MAAM;IACxBC,UAAUF,UAAUE,QAAQ;AAC9B,EAAE;AAEF;;CAEC,GACD,OAAO,MAAMW,kBAAkB,OAAOC,OAAO,IAAI;IAC/C,MAAMC,SAASnB,YAAYG;IAE3B,MAAMiB,SAASlB,KAAKmB,YAAY,CAAC,OAAOC,KAAKC;QAC3CA,IAAIC,SAAS,CAAC,+BAA+B;QAC7CD,IAAIC,SAAS,CAAC,gCAAgC;QAC9CD,IAAIC,SAAS,CAAC,gCAAgC;QAC9CD,IAAIC,SAAS,CAAC,gBAAgB;QAE9B,IAAIF,IAAIG,MAAM,KAAK,WAAW;YAC5BF,IAAIG,SAAS,CAAC;YACdH,IAAII,GAAG;YACP;QACF;QAEA,IAAIL,IAAIG,MAAM,KAAK,WAAW;YAC5BF,IAAIG,SAAS,CAAC;YACdH,IAAII,GAAG;YACP;QACF;QAEA,IAAIL,IAAIM,GAAG,KAAK,cAAcN,IAAIG,MAAM,KAAK,QAAQ;YACnD,0BAA0B;YAC1B,IAAII,OAAO;YACXP,IAAIQ,EAAE,CAAC,QAAQC,CAAAA;gBACbF,QAAQE,MAAMC,QAAQ;YACxB;YAEAV,IAAIQ,EAAE,CAAC,OAAO;gBACZ,IAAI;oBACF,MAAM,EAACG,KAAK,EAAEC,SAAS,EAAC,GAAGC,KAAKC,KAAK,CAACP;oBACtCQ,QAAQC,GAAG,CAAC,4BAA4B;wBAACL;wBAAOC;oBAAS;oBAEzD,mDAAmD;oBACnD,MAAMK,YAAY;wBAChBC,QAAQ,IAAM;wBACdC,OAAO,CAACC,SAASC,MAAMC,SAASC;4BAC9B,0DAA0D;4BAC1D,OAAO;gCACLC,QAAQ,CAACH;oCACP,MAAM,EAAChC,OAAO,EAAEoC,OAAO,CAAC,CAAC,EAAC,GAAGJ;oCAC7B,MAAM,EAACnC,QAAQ,EAAEF,QAAQ,EAAC,GAAGyC;oCAE7B,IAAIzC,aAAaF,UAAUE,QAAQ,IAAIE,aAAaJ,UAAUI,QAAQ,EAAE;wCACtE,OAAO;4CACLE,OAAOD,aAAaC,KAAK;4CACzBC,SAASA,WAAWF,aAAaE,OAAO;4CACxCK,QAAQP,aAAaO,MAAM;4CAC3BX,QAAQD,UAAUC,MAAM;4CACxBC,UAAUF,UAAUE,QAAQ;wCAC9B;oCACF;oCACA,MAAM,IAAI0C,MAAM;gCAClB;gCACAC,SAAS,CAACN;oCACR,MAAM,EAACI,IAAI,EAAC,GAAGJ;oCAEf,OAAO;wCACLtC,QAAQ,CAAC,KAAK,EAAES,KAAKC,GAAG,IAAI;wCAC5BT,UAAUyC,KAAKzC,QAAQ;wCACvBC,OAAOwC,KAAKxC,KAAK;oCACnB;gCACF;gCACA2C,gBAAgB,CAACP;oCACf,MAAM,EAACjC,KAAK,EAAEC,OAAO,EAAC,GAAGgC;oCAEzB,IAAIjC,UAAUD,aAAaC,KAAK,EAAE;wCAChC,OAAO;4CACLA,OAAOD,aAAaC,KAAK;4CACzBC,SAASA,WAAWF,aAAaE,OAAO;4CACxCK,QAAQJ,KAAKC,KAAK,CAACC,KAAKC,GAAG,KAAK;4CAChCV,QAAQD,UAAUC,MAAM;4CACxBC,UAAUF,UAAUE,QAAQ;wCAC9B;oCACF;oCACA,MAAM,IAAI0C,MAAM;gCAClB;4BACF;wBACF;oBACF;oBAEA,MAAMG,SAAS,MAAMlD,QAAQ;wBAC3BkB;wBACAiC,QAAQnB;wBACRM;wBACAc,gBAAgBnB,aAAa,CAAC;oBAChC;oBAEAG,QAAQC,GAAG,CAAC,kBAAkBH,KAAKmB,SAAS,CAACH,QAAQ,MAAM;oBAE3D5B,IAAIG,SAAS,CAAC;oBACdH,IAAII,GAAG,CAACQ,KAAKmB,SAAS,CAACH;gBACzB,EAAE,OAAOI,OAAO;oBACdlB,QAAQkB,KAAK,CAAC,wBAAwBA;oBACtChC,IAAIG,SAAS,CAAC;oBACd,MAAM8B,eAAeD,iBAAiBP,QAAQO,MAAME,OAAO,GAAGC,OAAOH;oBACrEhC,IAAII,GAAG,CAACQ,KAAKmB,SAAS,CAAC;wBACrBK,QAAQ;4BAAC;gCAACF,SAASD;4BAAY;yBAAE;oBACnC;gBACF;YACF;QACF,OAAO,IAAIlC,IAAIM,GAAG,KAAK,aAAaN,IAAIG,MAAM,KAAK,QAAQ;YACzD,8BAA8B;YAC9BY,QAAQC,GAAG,CAAC;YAEZ,kCAAkC;YAClCf,IAAIG,SAAS,CAAC;YACdH,IAAII,GAAG,CAACQ,KAAKmB,SAAS,CAAC;gBACrBM,MAAM;oBACJC,SAAS;oBACTjC,KAAK;gBACP;YACF;QACF,OAAO;YACLL,IAAIG,SAAS,CAAC;YACdH,IAAII,GAAG,CAACQ,KAAKmB,SAAS,CAAC;gBAACC,OAAO;YAAW;QAC5C;IACF;IAEA,OAAO,IAAIO,QAAQ,CAACC;QAClB3C,OAAO4C,MAAM,CAAC9C,MAAM;YAClBmB,QAAQC,GAAG,CAAC,CAAC,gDAAgD,EAAEpB,KAAK,QAAQ,CAAC;YAC7E6C,QAAQ;gBAAC3C;gBAAQF;YAAI;QACvB;IACF;AACF,EAAE;AAEF,+EAA+E;AAC/E+C,SAAS,4BAA4B;IACnCC,GAAG,8CAA8C;QAC/CC,OAAO,OAAOlD,iBAAiBmD,IAAI,CAAC;QACpCD,OAAO,OAAOE,gBAAgBD,IAAI,CAAC;IACrC;AACF;AAEA;;CAEC,GACD,OAAO,MAAMC,iBAAiB,CAACjD;IAC7B,OAAO,IAAI0C,QAAQ,CAACC;QAClB3C,OAAOkD,KAAK,CAACP;IACf;AACF,EAAE"}

package/lib/__tests__/e2e/helpers/testGraphQLServerSimple.d.ts

@@ -0,0 +1,3 @@
+export declare const startSimpleServer: (port?: number) => Promise<unknown>;
+export declare const stopServer: (server: any) => Promise<unknown>;
+//# sourceMappingURL=testGraphQLServerSimple.d.ts.map

package/lib/__tests__/e2e/helpers/testGraphQLServerSimple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testGraphQLServerSimple.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/e2e/helpers/testGraphQLServerSimple.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,GAAU,aAAW,qBAkClD,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,WAAM,qBAIhC,CAAC"}

package/lib/__tests__/e2e/helpers/testGraphQLServerSimple.js

@@ -0,0 +1,52 @@
+import http from 'http';
+export const startSimpleServer = async (port = 3002)=>{
+    const server = http.createServer((req, res)=>{
+        res.setHeader('Content-Type', 'application/json');
+        if (req.method === 'POST' && req.url === '/graphql') {
+            let body = '';
+            req.on('data', (chunk)=>{
+                body += chunk.toString();
+            });
+            req.on('end', ()=>{
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                    request: {
+                        method: req.method,
+                        url: req.url,
+                        body: body
+                    },
+                    response: {
+                        message: 'OK'
+                    }
+                }));
+            });
+        } else {
+            res.writeHead(404);
+            res.end(JSON.stringify({
+                error: 'not found'
+            }));
+        }
+    });
+    return new Promise((resolve)=>{
+        server.listen(port, ()=>{
+            resolve({
+                server,
+                port
+            });
+        });
+    });
+};
+export const stopServer = (server)=>{
+    return new Promise((resolve)=>{
+        server.close(resolve);
+    });
+};
+// Sanity check for Jest so this helper file has at least one test
+describe('testGraphQLServerSimple helper', ()=>{
+    it('exports startSimpleServer and stopServer', ()=>{
+        expect(typeof startSimpleServer).toBe('function');
+        expect(typeof stopServer).toBe('function');
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/appActions/appActions.d.ts

@@ -0,0 +1,29 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { AppType } from '../../types/apps.types.js';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export type AppAdapterOptions = BaseAdapterOptions;
+export interface AppActionsOptions {
+    appAdapter?: (input: unknown, options?: AppAdapterOptions) => any;
+    appAdapterOptions?: AppAdapterOptions;
+}
+export type AppApiResultsType = {
+    apps: {
+        add?: AppType;
+        itemById?: AppType;
+        list?: AppType[];
+        remove?: AppType;
+        update?: AppType;
+    };
+};
+export interface AppActions {
+    add: (appData: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;
+    delete: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;
+    itemById: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;
+    list: (from?: number, to?: number, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType[]>;
+    update: (app: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;
+    updateAppAdapter: (adapter: (input: unknown, options?: AppAdapterOptions) => any) => void;
+    updateAppAdapterOptions: (options: AppAdapterOptions) => void;
+}
+export declare const createAppActions: (flux: FluxFramework, options?: AppActionsOptions) => AppActions;
+//# sourceMappingURL=appActions.d.ts.map

package/lib/actions/appActions/appActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appActions.d.ts","sourceRoot":"","sources":["../../../src/actions/appActions/appActions.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,6BAA6B,CAAC;AAItE,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC;AAEnD,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,KAAK,GAAG,CAAC;IAClE,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE;QACJ,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;QACjB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjH,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACxG,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1G,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACrH,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAChH,gBAAgB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,KAAK,GAAG,KAAK,IAAI,CAAC;IAC1F,uBAAuB,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC/D;AAKD,eAAO,MAAM,gBAAgB,GAC3B,MAAM,aAAa,EACnB,UAAU,iBAAiB,KAC1B,UAyLF,CAAC"}

package/lib/actions/appActions/appActions.js

@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId, parseNum } from '@nlabs/utils';
+import { validateAppInput } from '../../adapters/appAdapter/appAdapter.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { createBaseActions } from '../../utils/baseActionFactory.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'apps';
+const defaultAppValidator = (input, options)=>validateAppInput(input);
+export const createAppActions = (flux, options)=>{
+    const appBase = createBaseActions(flux, defaultAppValidator, {
+        adapter: options?.appAdapter,
+        adapterOptions: options?.appAdapterOptions
+    });
+    const add = async (appData, appProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                app: {
+                    type: 'AppInput!',
+                    value: appBase.validator(appData)
+                }
+            };
+            return await appMutation(flux, 'add', DATA_TYPE, queryVariables, [
+                'appId',
+                ...appProps
+            ]);
+        } catch (error) {
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'app.list');
+        }
+    };
+    const itemById = async (appId, appProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `app.itemById:${appId}`, {
+                appId,
+                appProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                appId: {
+                    type: 'ID!',
+                    value: parseId(appId)
+                }
+            };
+            const result = await appQuery(flux, 'itemById', DATA_TYPE, queryVariables, [
+                'apiKey',
+                'appId',
+                'description',
+                'imageUrl',
+                'isActive',
+                'name',
+                'settings',
+                'url',
+                'userId',
+                ...appProps
+            ]);
+            return await setCachedRequest(flux, `app.itemById:${appId}`, {
+                appId,
+                appProps
+            }, result, requestOptions);
+        } catch (error) {
+            throw error;
+        }
+    };
+    const list = async (from = 0, to = 10, appProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'app.list', {
+                from,
+                to,
+                appProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const result = await appQuery(flux, 'list', DATA_TYPE, queryVariables, [
+                'apiKey',
+                'appId',
+                'description',
+                'imageUrl',
+                'isActive',
+                'name',
+                'settings',
+                'url',
+                'userId',
+                ...appProps
+            ]);
+            return await setCachedRequest(flux, 'app.list', {
+                from,
+                to,
+                appProps
+            }, result, requestOptions);
+        } catch (error) {
+            throw error;
+        }
+    };
+    const deleteApp = async (appId, appProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                appId: {
+                    type: 'ID!',
+                    value: parseId(appId)
+                }
+            };
+            return await appMutation(flux, 'remove', DATA_TYPE, queryVariables, [
+                'appId',
+                ...appProps
+            ]);
+        } catch (error) {
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `app.itemById:${appId}`);
+            await clearCachedRequest(flux, 'app.list');
+        }
+    };
+    const update = async (app, appProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                app: {
+                    type: 'AppUpdateInput!',
+                    value: appBase.validator(app)
+                }
+            };
+            return await appMutation(flux, 'update', DATA_TYPE, queryVariables, [
+                'appId',
+                ...appProps
+            ]);
+        } catch (error) {
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `app.itemById:${String(app?.appId || '')}`);
+            await clearCachedRequest(flux, 'app.list');
+        }
+    };
+    return {
+        add,
+        delete: deleteApp,
+        itemById,
+        list,
+        update,
+        updateAppAdapter: appBase.updateAdapter,
+        updateAppAdapterOptions: appBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/appActions/appActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {parseId, parseNum} from '@nlabs/utils';\n\nimport {validateAppInput} from '../../adapters/appAdapter/appAdapter.js';\nimport {appMutation, appQuery} from '../../utils/api.js';\nimport {createBaseActions} from '../../utils/baseActionFactory.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {AppType} from '../../types/apps.types.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'apps';\n\nexport type AppAdapterOptions = BaseAdapterOptions;\n\nexport interface AppActionsOptions {\n  appAdapter?: (input: unknown, options?: AppAdapterOptions) => any;\n  appAdapterOptions?: AppAdapterOptions;\n}\n\nexport type AppApiResultsType = {\n  apps: {\n    add?: AppType;\n    itemById?: AppType;\n    list?: AppType[];\n    remove?: AppType;\n    update?: AppType;\n  };\n};\n\nexport interface AppActions {\n  add: (appData: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  delete: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  itemById: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  list: (from?: number, to?: number, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType[]>;\n  update: (app: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  updateAppAdapter: (adapter: (input: unknown, options?: AppAdapterOptions) => any) => void;\n  updateAppAdapterOptions: (options: AppAdapterOptions) => void;\n}\n\nconst defaultAppValidator = (input: unknown, options?: AppAdapterOptions) =>\n  validateAppInput(input);\n\nexport const createAppActions = (\n  flux: FluxFramework,\n  options?: AppActionsOptions\n): AppActions => {\n  const appBase = createBaseActions(flux, defaultAppValidator, {\n    adapter: options?.appAdapter,\n    adapterOptions: options?.appAdapterOptions\n  });\n\n  const add = async (\n    appData: Partial<AppType>,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        app: {\n          type: 'AppInput!',\n          value: appBase.validator(appData)\n        }\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'add',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps]\n      );\n    } catch(error) {\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  const itemById = async (appId: string, appProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<AppType> => {\n    try {\n      const cachedResult = getCachedRequest<AppType>(flux, `app.itemById:${appId}`, {appId, appProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        appId: {\n          type: 'ID!',\n          value: parseId(appId)\n        }\n      };\n\n      const result = await appQuery<AppType>(\n        flux,\n        'itemById',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'apiKey',\n          'appId',\n          'description',\n          'imageUrl',\n          'isActive',\n          'name',\n          'settings',\n          'url',\n          'userId',\n          ...appProps\n        ]\n      );\n      return await setCachedRequest(flux, `app.itemById:${appId}`, {appId, appProps}, result, requestOptions);\n    } catch(error) {\n      throw error;\n    }\n  };\n\n  const list = async (\n    from: number = 0,\n    to: number = 10,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType[]> => {\n    try {\n      const cachedResult = getCachedRequest<AppType[]>(flux, 'app.list', {from, to, appProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const result = await appQuery<AppType[]>(\n        flux,\n        'list',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'apiKey',\n          'appId',\n          'description',\n          'imageUrl',\n          'isActive',\n          'name',\n          'settings',\n          'url',\n          'userId',\n          ...appProps\n        ]\n      );\n      return await setCachedRequest(flux, 'app.list', {from, to, appProps}, result, requestOptions);\n    } catch(error) {\n      throw error;\n    }\n  };\n\n  const deleteApp = async (\n    appId: string,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        appId: {\n          type: 'ID!',\n          value: parseId(appId)\n        }\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'remove',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps]\n      );\n    } catch(error) {\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `app.itemById:${appId}`);\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  const update = async (\n    app: Partial<AppType>,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        app: {\n          type: 'AppUpdateInput!',\n          value: appBase.validator(app)\n        }\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'update',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps]\n      );\n    } catch(error) {\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `app.itemById:${String(app?.appId || '')}`);\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  return {\n    add,\n    delete: deleteApp,\n    itemById,\n    list,\n    update,\n    updateAppAdapter: appBase.updateAdapter,\n    updateAppAdapterOptions: appBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validateAppInput","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultAppValidator","input","options","createAppActions","flux","appBase","adapter","appAdapter","adapterOptions","appAdapterOptions","add","appData","appProps","requestOptions","queryVariables","app","type","value","validator","error","itemById","appId","cachedResult","undefined","result","list","from","to","deleteApp","update","String","delete","updateAppAdapter","updateAdapter","updateAppAdapterOptions","updateOptions"],"mappings":"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"}

package/lib/actions/connectionActions/connectionActions.d.ts

@@ -0,0 +1,19 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { CollectionType, ConnectionType } from '../../constants/Collections.js';
+import type { ApiResultsType } from '../../utils/api.js';
+import type { ConnectionEdge } from '../../types/edges.types.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface ConnectionActions {
+    addConnection: (fromType: CollectionType, fromId: string, toType: CollectionType, toId: string, connectionType?: ConnectionType, metadata?: Record<string, any>, requestOptions?: ActionRequestOptions) => Promise<ConnectionEdge>;
+    getConnections: (fromType: CollectionType, fromId: string, toType?: CollectionType, filters?: Record<string, any>, requestOptions?: ActionRequestOptions) => Promise<ConnectionEdge[]>;
+    removeConnection: (fromType: CollectionType, fromId: string, toType: CollectionType, toId: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;
+}
+export interface ConnectionApiResultsType extends ApiResultsType {
+    connections?: {
+        add?: ConnectionEdge;
+        list?: ConnectionEdge[];
+        remove?: boolean;
+    };
+}
+export declare const createConnectionActions: (flux: FluxFramework) => ConnectionActions;
+//# sourceMappingURL=connectionActions.d.ts.map

package/lib/actions/connectionActions/connectionActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionActions.d.ts","sourceRoot":"","sources":["../../../src/actions/connectionActions/connectionActions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAC,cAAc,EAAE,cAAc,EAAC,MAAM,gCAAgC,CAAC;AACnF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,6BAA6B,CAAC;AAEtE,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,CACb,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,cAAc,EAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,cAAc,CAAC,EAAE,oBAAoB,KAClC,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7B,cAAc,EAAE,CACd,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,cAAc,CAAC,EAAE,oBAAoB,KAClC,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC/B,gBAAgB,EAAE,CAChB,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,MAAM,EACZ,cAAc,CAAC,EAAE,oBAAoB,KAClC,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,wBAAyB,SAAQ,cAAc;IAC9D,WAAW,CAAC,EAAE;QACZ,GAAG,CAAC,EAAE,cAAc,CAAC;QACrB,IAAI,CAAC,EAAE,cAAc,EAAE,CAAC;QACxB,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;CACH;AAED,eAAO,MAAM,uBAAuB,GAAI,MAAM,aAAa,KAAG,iBA+K7D,CAAC"}