@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/websockets.js

@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { ApiGatewayManagementApi } from '@aws-sdk/client-apigatewaymanagementapi';
+import { createHash, parseId, parseString } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { Config } from '../config.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { getUserByToken } from './users.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+export const addSocket = async (socketId, token)=>{
+    const action = 'addSocket';
+    const formatSocketId = parseString(socketId, 32);
+    const formatToken = parseString(token);
+    try {
+        const databaseName = process.env.ARANGODB_DATABASE || '';
+        const database = useDb(databaseName);
+        const user = await getUserByToken({
+            config: Config.get(),
+            databaseName
+        }, formatToken);
+        if (!user) {
+            throw new Error('Unauthorized');
+        }
+        const update = {
+            socketId: formatSocketId,
+            modified: Date.now()
+        };
+        const insert = {
+            ...update,
+            _key: createHash(`socket-${formatSocketId}`),
+            userId: user.userId
+        };
+        const aqlQry = aql`UPSERT {userId: ${user.userId}}
+      INSERT ${insert}
+      UPDATE ${update}
+      IN sockets RETURN NEW`;
+        return database.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+            throw logError({
+                action,
+                category: 'websockets',
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, {});
+        });
+    } catch (error) {
+        throw new Error('Unauthorized');
+    }
+};
+export const getSocketByUser = (userId)=>{
+    const formatUserId = parseId(userId);
+    const databaseName = process.env.ARANGODB_DATABASE || '';
+    const database = useDb(databaseName);
+    const aqlQry = aql`FOR s IN sockets
+    FILTER s.userId == ${formatUserId}
+    LIMIT 1
+    RETURN s`;
+    return database.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+export const getSocketById = (socketId)=>{
+    const formatSocketId = parseId(socketId);
+    const databaseName = process.env.ARANGODB_DATABASE || '';
+    const database = useDb(databaseName);
+    const aqlQry = aql`FOR s IN sockets
+    FILTER s.socketId == ${formatSocketId}
+    LET user = FIRST(
+      FOR u IN users
+      FILTER u.sub == s.sub
+      LIMIT 1
+      RETURN u;
+    )
+    LIMIT 1
+    RETURN MERGE(c, {user:user}`;
+    return database.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw error;
+    });
+};
+export const getConnectionByConvo = (context, convoId)=>{
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const sessionDocId = `users/${parseId(sessionId)}`;
+    const convoDocId = `conversations/${parseId(convoId)}`;
+    const database = useDb(databaseName);
+    const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation
+  FILTER c._id == ${convoDocId}
+  LIMIT 1
+  LET u = (
+    FOR inUser, inEdge IN 1..1 INBOUND ${convoDocId} hasConversation
+    FOR n IN connections
+    FILTER inUser.sub == n.sub
+    RETURN n.connectionId
+  )
+  RETURN u`;
+    return database.query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        throw error;
+    });
+};
+export const removeSocket = (socketId)=>{
+    const action = 'removeSocket';
+    const formatSocketId = parseString(socketId, 32);
+    const databaseName = process.env.ARANGODB_DATABASE || '';
+    const database = useDb(databaseName);
+    const aqlQry = aql`FOR s IN sockets
+      FILTER s.socketId == ${formatSocketId}
+      LIMIT 1
+      REMOVE s IN sockets
+      RETURN OLD`;
+    return database.query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>{
+        throw logError({
+            action,
+            category: 'websockets',
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+    });
+};
+export class WebsocketClient {
+    client;
+    constructor(config){
+        if (config) {
+            this.setupClient(config || {});
+        }
+    }
+    // Allow just passing a single event to setup the client for ease of use
+    async setupClient({ requestContext }) {
+        if (!this.client && requestContext) {
+            const { apiId, domainName, stage } = requestContext;
+            let updatedDomainName = domainName;
+            if (apiId) {
+                updatedDomainName = `${apiId}.execute-api.${process.env.API_REGION}.amazonaws.com`;
+            }
+            this.client = new ApiGatewayManagementApi({
+                credentials: Config.get('aws.credentials'),
+                endpoint: `https://${updatedDomainName}/${stage}`,
+                region: Config.get('aws.region')
+            });
+        }
+    }
+    async send(connection, payload) {
+        console.log(connection, payload);
+        // Cheat and allow event to be passed in this also lets us default to setupClient too
+        let socketId;
+        if (connection?.requestContext) {
+            await this.setupClient(connection);
+            const { socketId: updatedSocketId } = connection.requestContext;
+            socketId = updatedSocketId;
+        } else {
+            socketId = connection;
+        }
+        await this.client.postToConnection({
+            ConnectionId: socketId,
+            Data: JSON.stringify(payload)
+        }).promise().catch(async (postError)=>{
+            console.log(JSON.stringify(postError));
+            if (postError.statusCode === 410) {
+                // Disconnect client
+                await removeSocket(socketId);
+            }
+        });
+        return true;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/websockets.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {ApiGatewayManagementApi} from '@aws-sdk/client-apigatewaymanagementapi';\nimport {createHash, parseId, parseString} from '@nlabs/utils/parsers/strings';\nimport {aql, Database} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\n\nimport {Config} from '../config.js';\nimport {ApiContext} from '../types/auth.types.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {getUserByToken} from './users.js';\n\nimport {ErrorTypes} from '../types/error.types.js';\nimport type {WebsocketConnection} from '../types/websockets.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\n\nexport const addSocket = async (socketId: string, token: string): Promise<WebsocketConnection> => {\n  const action: string = 'addSocket';\n  const formatSocketId: string = parseString(socketId, 32);\n  const formatToken: string = parseString(token);\n\n  try {\n    const databaseName: string = process.env.ARANGODB_DATABASE || '';\n    const database: Database = useDb(databaseName);\n    const user = await getUserByToken({config: Config.get(), databaseName}, formatToken);\n\n    if(!user) {\n      throw new Error('Unauthorized');\n    }\n\n    const update = {\n      socketId: formatSocketId,\n      modified: Date.now()\n    };\n    const insert = {\n      ...update,\n      _key: createHash(`socket-${formatSocketId}`),\n      userId: user.userId\n    };\n    const aqlQry: AqlQuery = aql`UPSERT {userId: ${user.userId}}\n      INSERT ${insert}\n      UPDATE ${update}\n      IN sockets RETURN NEW`;\n\n    return database.query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => {\n        throw logError({\n          action,\n          category: 'websockets',\n          value: ErrorTypes.DATABASE_ERROR\n        }, error, {});\n      });\n  } catch(error) {\n    throw new Error('Unauthorized');\n  }\n};\n\nexport const getSocketByUser = (userId: string): Promise<WebsocketConnection> => {\n  const formatUserId: string = parseId(userId);\n  const databaseName: string = process.env.ARANGODB_DATABASE || '';\n  const database: Database = useDb(databaseName);\n  const aqlQry = aql`FOR s IN sockets\n    FILTER s.userId == ${formatUserId}\n    LIMIT 1\n    RETURN s`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getSocketById = (socketId: string): Promise<any> => {\n  const formatSocketId: string = parseId(socketId);\n  const databaseName: string = process.env.ARANGODB_DATABASE || '';\n  const database: Database = useDb(databaseName);\n  const aqlQry = aql`FOR s IN sockets\n    FILTER s.socketId == ${formatSocketId}\n    LET user = FIRST(\n      FOR u IN users\n      FILTER u.sub == s.sub\n      LIMIT 1\n      RETURN u;\n    )\n    LIMIT 1\n    RETURN MERGE(c, {user:user}`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const getConnectionByConvo = (context: ApiContext, convoId: string): Promise<any> => {\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const sessionDocId: string = `users/${parseId(sessionId)}`;\n  const convoDocId: string = `conversations/${parseId(convoId)}`;\n  const database: Database = useDb(databaseName);\n  const aqlQry = aql`FOR c, e IN 1..1 OUTBOUND ${sessionDocId} hasConversation\n  FILTER c._id == ${convoDocId}\n  LIMIT 1\n  LET u = (\n    FOR inUser, inEdge IN 1..1 INBOUND ${convoDocId} hasConversation\n    FOR n IN connections\n    FILTER inUser.sub == n.sub\n    RETURN n.connectionId\n  )\n  RETURN u`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const removeSocket = (socketId: string): Promise<WebsocketConnection> => {\n  const action: string = 'removeSocket';\n  const formatSocketId: string = parseString(socketId, 32);\n  const databaseName: string = process.env.ARANGODB_DATABASE || '';\n  const database: Database = useDb(databaseName);\n  const aqlQry = aql`FOR s IN sockets\n      FILTER s.socketId == ${formatSocketId}\n      LIMIT 1\n      REMOVE s IN sockets\n      RETURN OLD`;\n\n  return database.query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => {\n      throw logError({\n        action,\n        category: 'websockets',\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n    });\n};\n\nexport interface WebSocketClientContext {\n  readonly requestContext?: {\n    readonly apiId: string;\n    readonly domainName: string;\n    readonly stage: string;\n  };\n}\nexport class WebsocketClient {\n  client;\n\n  constructor(config?) {\n    if(config) {\n      this.setupClient(config || {});\n    }\n  }\n\n  // Allow just passing a single event to setup the client for ease of use\n  async setupClient({requestContext}: WebSocketClientContext) {\n    if(!this.client && requestContext) {\n      const {apiId, domainName, stage} = requestContext;\n      let updatedDomainName: string = domainName;\n\n      if(apiId) {\n        updatedDomainName = `${apiId}.execute-api.${process.env.API_REGION}.amazonaws.com`;\n      }\n\n      this.client = new ApiGatewayManagementApi({\n        credentials: Config.get('aws.credentials'),\n        endpoint: `https://${updatedDomainName}/${stage}`,\n        region: Config.get('aws.region')\n      });\n    }\n  }\n\n  async send(connection, payload) {\n    console.log(connection, payload);\n\n    // Cheat and allow event to be passed in this also lets us default to setupClient too\n    let socketId;\n\n    if(connection?.requestContext) {\n      await this.setupClient(connection);\n      const {socketId: updatedSocketId} = connection.requestContext;\n      socketId = updatedSocketId;\n    } else {\n      socketId = connection;\n    }\n\n    await this.client.postToConnection({ConnectionId: socketId, Data: JSON.stringify(payload)})\n      .promise()\n      .catch(async (postError) => {\n        console.log(JSON.stringify(postError));\n\n        if(postError.statusCode === 410) {\n          // Disconnect client\n          await removeSocket(socketId);\n        }\n      });\n\n    return true;\n  }\n}\n"],"names":["ApiGatewayManagementApi","createHash","parseId","parseString","aql","Config","useDb","getUserByToken","ErrorTypes","logError","addSocket","socketId","token","action","formatSocketId","formatToken","databaseName","process","env","ARANGODB_DATABASE","database","user","config","get","Error","update","modified","Date","now","insert","_key","userId","aqlQry","query","then","cursor","next","catch","error","category","value","DATABASE_ERROR","getSocketByUser","formatUserId","getSocketById","getConnectionByConvo","context","convoId","session","sessionId","sessionDocId","convoDocId","all","removeSocket","WebsocketClient","client","setupClient","requestContext","apiId","domainName","stage","updatedDomainName","API_REGION","credentials","endpoint","region","send","connection","payload","console","log","updatedSocketId","postToConnection","ConnectionId","Data","JSON","stringify","promise","postError","statusCode"],"mappings":"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"}

package/lib/adapters/arangoAdapter.d.ts

@@ -6,3 +6,4 @@ export declare class ArangoValidationError extends Error {
 export declare const validateDocumentInput: (doc: unknown) => DocumentType;
 export declare const formatDocumentOutput: (doc: DocumentType) => DocumentType;
 export declare const parseDocument: (doc: DocumentType) => DocumentType;
+//# sourceMappingURL=arangoAdapter.d.ts.map

package/lib/adapters/arangoAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arangoAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/arangoAdapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,MAAM,4BAA4B,CAAC;AAGxD,qBAAa,qBAAsB,SAAQ,KAAK;IACV,KAAK,CAAC,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,MAAM;CAInD;AAcD,eAAO,MAAM,qBAAqB,GAAI,KAAK,OAAO,KAAG,YAWpD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,KAAK,YAAY,KAAG,YAAmB,CAAC;AAE7E,eAAO,MAAM,aAAa,GAAI,KAAK,YAAY,KAAG,YAUjD,CAAC"}

package/lib/adapters/arangoAdapter.js

@@ -0,0 +1,70 @@
+import { parseNum } from '@nlabs/utils/parsers/numbers';
+import { parseArangoId, parseId } from '@nlabs/utils/parsers/strings';
+import { z } from 'zod';
+import { removeEmptyKeys } from '../utils/adapterUtils.js';
+export class ArangoValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'ArangoValidationError';
+    }
+}
+const DocumentInputSchema = z.object({
+    _from: z.string().optional(),
+    _id: z.string().optional(),
+    _key: z.string().optional(),
+    _oldRev: z.string().optional(),
+    _rev: z.string().optional(),
+    _to: z.string().optional(),
+    added: z.number().optional(),
+    id: z.string().optional(),
+    modified: z.number().optional()
+}).passthrough();
+export const validateDocumentInput = (doc)=>{
+    try {
+        const validated = DocumentInputSchema.parse(doc);
+        return validated;
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const fieldErrors = error.issues.map((e)=>`${e.path.join('.')}: ${e.message}`).join(', ');
+            throw new ArangoValidationError(`Document validation failed: ${fieldErrors}`);
+        }
+        throw error;
+    }
+};
+export const formatDocumentOutput = (doc)=>doc;
+export const parseDocument = (doc)=>{
+    try {
+        const parsed = performDocumentTransformation(doc);
+        return parsed;
+    } catch (error) {
+        if (error instanceof ArangoValidationError) {
+            throw error;
+        }
+        throw new ArangoValidationError(`Document parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+const performDocumentTransformation = (doc)=>{
+    const { _id, _key, added, id, modified } = doc;
+    const transformed = removeEmptyKeys({
+        ...doc,
+        ..._id && {
+            _id: parseArangoId(_id)
+        },
+        ..._key && {
+            _key: parseId(_key)
+        },
+        ...added !== undefined && {
+            added: parseNum(added, 13)
+        },
+        ...(_id || id) && {
+            id: parseArangoId(_id || id)
+        },
+        ...modified !== undefined && {
+            modified: parseNum(modified, 13)
+        }
+    });
+    return transformed;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/adapters/contentAdapter.d.ts

@@ -6,3 +6,4 @@ export declare class ContentValidationError extends Error {
 export declare const parseContent: (content: ContentType) => ContentType;
 export declare const parseContentInput: (content: ContentInputType) => ContentInputType;
 export declare const parseContentFromDb: (content: ContentType) => ContentType;
+//# sourceMappingURL=contentAdapter.d.ts.map

package/lib/adapters/contentAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/contentAdapter.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,gBAAgB,EAAE,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAIxE,qBAAa,sBAAuB,SAAQ,KAAK;IACX,KAAK,CAAC,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,MAAM;CAInD;AA2BD,eAAO,MAAM,YAAY,GAAI,SAAS,WAAW,KAAG,WAYnD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,SAAS,gBAAgB,KAAG,gBAY7D,CAAC;AAiCF,eAAO,MAAM,kBAAkB,GAAI,SAAS,WAAW,KAAG,WAAoD,CAAC"}

package/lib/adapters/contentAdapter.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseArangoId, parseId, parseString } from '@nlabs/utils/parsers/strings';
+import { z } from 'zod';
+import { removeEmptyKeys } from '../utils/adapterUtils.js';
+import { parseDocument } from './arangoAdapter.js';
+export class ContentValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'ContentValidationError';
+    }
+}
+const contentSchema = z.object({
+    contentId: z.string().optional(),
+    key: z.string().min(1, 'Key is required').max(200, 'Key must be less than 200 characters'),
+    locale: z.enum([
+        'en',
+        'es',
+        'fr',
+        'de',
+        'pt',
+        'it'
+    ], {
+        message: 'Locale must be one of: en, es, fr, de, pt, it'
+    }),
+    content: z.string().min(1, 'Content is required').max(10000, 'Content must be less than 10000 characters'),
+    description: z.string().max(500, 'Description must be less than 500 characters').optional(),
+    category: z.string().max(100, 'Category must be less than 100 characters').optional(),
+    isActive: z.boolean().optional(),
+    userId: z.string().optional()
+});
+const contentInputSchema = z.object({
+    contentId: z.string().optional(),
+    key: z.string().min(1, 'Key is required').max(200, 'Key must be less than 200 characters'),
+    locale: z.enum([
+        'en',
+        'es',
+        'fr',
+        'de',
+        'pt',
+        'it'
+    ], {
+        message: 'Locale must be one of: en, es, fr, de, pt, it'
+    }).optional(),
+    content: z.string().min(1, 'Content is required').max(10000, 'Content must be less than 10000 characters'),
+    description: z.string().max(500, 'Description must be less than 500 characters').optional(),
+    category: z.string().max(100, 'Category must be less than 100 characters').optional(),
+    isActive: z.boolean().optional()
+});
+export const parseContent = (content)=>{
+    try {
+        const validated = contentSchema.parse(content);
+        return validated;
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const field = error.issues[0]?.path.join('.');
+            const message = error.issues[0]?.message || 'Validation failed';
+            throw new ContentValidationError(message, field);
+        }
+        throw error;
+    }
+};
+export const parseContentInput = (content)=>{
+    try {
+        const validated = contentInputSchema.parse(content);
+        return validated;
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const field = error.issues[0]?.path.join('.');
+            const message = error.issues[0]?.message || 'Validation failed';
+            throw new ContentValidationError(message, field);
+        }
+        throw error;
+    }
+};
+const performContentTransformation = (content)=>{
+    const { _id, _key, contentId, id, key, locale, content: contentText, description, category, isActive, userId } = content;
+    const transformed = {
+        ...parseDocument(content),
+        ...(_key || contentId) && {
+            contentId: parseId(_key || contentId)
+        },
+        ...(_id || id || _key || contentId) && {
+            id: parseArangoId(_id || id || `content/${_key || contentId}`)
+        },
+        key: parseString(key, 200),
+        locale,
+        content: parseString(contentText, 10000),
+        ...description && {
+            description: parseString(description, 500)
+        },
+        ...category && {
+            category: parseString(category, 100)
+        },
+        ...isActive !== undefined && {
+            isActive
+        },
+        ...userId && {
+            userId: parseId(userId)
+        }
+    };
+    return removeEmptyKeys(transformed);
+};
+export const parseContentFromDb = (content)=>performContentTransformation(content);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/adapters/contentAdapter.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {parseArangoId, parseId, parseString} from '@nlabs/utils/parsers/strings';\nimport {z} from 'zod';\n\nimport {ContentInputType, ContentType} from '../types/content.types.js';\nimport {removeEmptyKeys} from '../utils/adapterUtils.js';\nimport {parseDocument} from './arangoAdapter.js';\n\nexport class ContentValidationError extends Error {\n  constructor(message: string, public field?: string) {\n    super(message);\n    this.name = 'ContentValidationError';\n  }\n}\n\nconst contentSchema = z.object({\n  contentId: z.string().optional(),\n  key: z.string().min(1, 'Key is required').max(200, 'Key must be less than 200 characters'),\n  locale: z.enum(['en', 'es', 'fr', 'de', 'pt', 'it'], {\n    message: 'Locale must be one of: en, es, fr, de, pt, it'\n  }),\n  content: z.string().min(1, 'Content is required').max(10000, 'Content must be less than 10000 characters'),\n  description: z.string().max(500, 'Description must be less than 500 characters').optional(),\n  category: z.string().max(100, 'Category must be less than 100 characters').optional(),\n  isActive: z.boolean().optional(),\n  userId: z.string().optional()\n});\n\nconst contentInputSchema = z.object({\n  contentId: z.string().optional(),\n  key: z.string().min(1, 'Key is required').max(200, 'Key must be less than 200 characters'),\n  locale: z.enum(['en', 'es', 'fr', 'de', 'pt', 'it'], {\n    message: 'Locale must be one of: en, es, fr, de, pt, it'\n  }).optional(),\n  content: z.string().min(1, 'Content is required').max(10000, 'Content must be less than 10000 characters'),\n  description: z.string().max(500, 'Description must be less than 500 characters').optional(),\n  category: z.string().max(100, 'Category must be less than 100 characters').optional(),\n  isActive: z.boolean().optional()\n});\n\nexport const parseContent = (content: ContentType): ContentType => {\n  try {\n    const validated = contentSchema.parse(content);\n    return validated as ContentType;\n  } catch(error) {\n    if(error instanceof z.ZodError) {\n      const field = error.issues[0]?.path.join('.');\n      const message = error.issues[0]?.message || 'Validation failed';\n      throw new ContentValidationError(message, field);\n    }\n    throw error;\n  }\n};\n\nexport const parseContentInput = (content: ContentInputType): ContentInputType => {\n  try {\n    const validated = contentInputSchema.parse(content);\n    return validated as ContentInputType;\n  } catch(error) {\n    if(error instanceof z.ZodError) {\n      const field = error.issues[0]?.path.join('.');\n      const message = error.issues[0]?.message || 'Validation failed';\n      throw new ContentValidationError(message, field);\n    }\n    throw error;\n  }\n};\n\nconst performContentTransformation = (content: ContentType): ContentType => {\n  const {\n    _id,\n    _key,\n    contentId,\n    id,\n    key,\n    locale,\n    content: contentText,\n    description,\n    category,\n    isActive,\n    userId\n  } = content;\n\n  const transformed = {\n    ...parseDocument(content),\n    ...((_key || contentId) && {contentId: parseId(_key || contentId)}),\n    ...((_id || id || _key || contentId) && {id: parseArangoId(_id || id || `content/${_key || contentId}`)}),\n    key: parseString(key, 200),\n    locale,\n    content: parseString(contentText, 10000),\n    ...(description && {description: parseString(description, 500)}),\n    ...(category && {category: parseString(category, 100)}),\n    ...(isActive !== undefined && {isActive}),\n    ...(userId && {userId: parseId(userId)})\n  };\n\n  return removeEmptyKeys(transformed) as ContentType;\n};\n\nexport const parseContentFromDb = (content: ContentType): ContentType => performContentTransformation(content);"],"names":["parseArangoId","parseId","parseString","z","removeEmptyKeys","parseDocument","ContentValidationError","Error","message","field","name","contentSchema","object","contentId","string","optional","key","min","max","locale","enum","content","description","category","isActive","boolean","userId","contentInputSchema","parseContent","validated","parse","error","ZodError","issues","path","join","parseContentInput","performContentTransformation","_id","_key","id","contentText","transformed","undefined","parseContentFromDb"],"mappings":"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"}

package/lib/adapters/fileAdapter.d.ts

@@ -7,3 +7,4 @@ export declare const validateFileInput: (file: unknown) => FileType;
 export declare const formatFileOutput: (file: FileType) => FileType;
 export declare const getFileType: (file: FileType) => string | undefined;
 export declare const parseFile: (file: FileType) => FileType;
+//# sourceMappingURL=fileAdapter.d.ts.map

package/lib/adapters/fileAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/fileAdapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAC,MAAM,yBAAyB,CAAC;AAIjD,qBAAa,mBAAoB,SAAQ,KAAK;IACR,KAAK,CAAC,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,MAAM;CAInD;AAsBD,eAAO,MAAM,iBAAiB,GAAI,MAAM,OAAO,KAAG,QAWjD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,QAAQ,KAAG,QAAgB,CAAC;AAEnE,eAAO,MAAM,WAAW,GAAI,MAAM,QAAQ,KAAG,MAAM,GAAG,SAqBrD,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,MAAM,QAAQ,KAAG,QAU1C,CAAC"}

package/lib/adapters/fileAdapter.js

@@ -0,0 +1,119 @@
+import { parseNum } from '@nlabs/utils/parsers/numbers';
+import { parseArangoId, parseId, parseString, parseUrl } from '@nlabs/utils/parsers/strings';
+import { z } from 'zod';
+import { parseDocument } from './arangoAdapter.js';
+import { parseReaktorContent, parseReaktorType } from './reaktorAdapter.js';
+export class FileValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'FileValidationError';
+    }
+}
+const FileInputSchema = z.object({
+    _from: z.string().optional(),
+    _id: z.string().optional(),
+    _key: z.string().optional(),
+    _oldRev: z.string().optional(),
+    _rev: z.string().optional(),
+    _to: z.string().optional(),
+    base64: z.string().optional(),
+    buffer: z.any().optional(),
+    description: z.string().optional(),
+    fileId: z.string().optional(),
+    fileSize: z.number().optional(),
+    fileType: z.string().optional(),
+    itemId: z.string().optional(),
+    itemType: z.string().optional(),
+    name: z.string().optional(),
+    url: z.string().optional(),
+    userId: z.string().optional()
+}).passthrough();
+export const validateFileInput = (file)=>{
+    try {
+        const validated = FileInputSchema.parse(file);
+        return validated;
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const fieldErrors = error.issues.map((e)=>`${e.path.join('.')}: ${e.message}`).join(', ');
+            throw new FileValidationError(`File validation failed: ${fieldErrors}`);
+        }
+        throw error;
+    }
+};
+export const formatFileOutput = (file)=>file;
+export const getFileType = (file)=>{
+    const { fileType, name } = file;
+    if (fileType) {
+        return parseString(fileType, 16);
+    }
+    const nameArr = name?.split('.') || [];
+    const ext = nameArr.length && nameArr[nameArr.length - 1] || '';
+    switch(ext){
+        case 'jpeg':
+        case 'jpg':
+            return 'image/jpeg';
+        case 'png':
+            return 'image/png';
+        case 'zip':
+            return 'application/zip';
+        default:
+            return undefined;
+    }
+};
+export const parseFile = (file)=>{
+    try {
+        const parsed = performFileTransformation(file);
+        return parsed;
+    } catch (error) {
+        if (error instanceof FileValidationError) {
+            throw error;
+        }
+        throw new FileValidationError(`File parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+const performFileTransformation = (file)=>{
+    const { _id, _key, base64, buffer, description, fileId, fileSize, fileType, id, itemId, itemType, name, url, userId } = file;
+    const transformed = {
+        ...parseDocument(file),
+        ...base64 && {
+            base64
+        },
+        ...buffer && {
+            buffer
+        },
+        ...description && {
+            description: parseReaktorContent(description)
+        },
+        ...(_key || fileId) && {
+            fileId: parseId(_key || fileId)
+        },
+        ...(_id || id || _key || fileId) && {
+            id: parseArangoId(_id || id || `files/${_key || fileId}`)
+        },
+        ...fileSize !== undefined && {
+            fileSize: parseNum(fileSize)
+        },
+        ...fileType && {
+            fileType: getFileType(file)
+        },
+        ...itemId && {
+            itemId: parseId(itemId)
+        },
+        ...itemType && {
+            itemType: parseReaktorType(itemType)
+        },
+        ...name && {
+            name: parseString(name, 160)
+        },
+        ...url && {
+            url: parseUrl(url)
+        },
+        ...userId && {
+            userId: parseId(userId)
+        }
+    };
+    return transformed;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/adapters/fileAdapter.ts"],"sourcesContent":["import {parseNum} from '@nlabs/utils/parsers/numbers';\nimport {parseArangoId, parseId, parseString, parseUrl} from '@nlabs/utils/parsers/strings';\nimport {z} from 'zod';\n\nimport {FileType} from '../types/files.types.js';\nimport {parseDocument} from './arangoAdapter.js';\nimport {parseReaktorContent, parseReaktorType} from './reaktorAdapter.js';\n\nexport class FileValidationError extends Error {\n  constructor(message: string, public field?: string) {\n    super(message);\n    this.name = 'FileValidationError';\n  }\n}\n\nconst FileInputSchema = z.object({\n  _from: z.string().optional(),\n  _id: z.string().optional(),\n  _key: z.string().optional(),\n  _oldRev: z.string().optional(),\n  _rev: z.string().optional(),\n  _to: z.string().optional(),\n  base64: z.string().optional(),\n  buffer: z.any().optional(),\n  description: z.string().optional(),\n  fileId: z.string().optional(),\n  fileSize: z.number().optional(),\n  fileType: z.string().optional(),\n  itemId: z.string().optional(),\n  itemType: z.string().optional(),\n  name: z.string().optional(),\n  url: z.string().optional(),\n  userId: z.string().optional()\n}).passthrough();\n\nexport const validateFileInput = (file: unknown): FileType => {\n  try {\n    const validated = FileInputSchema.parse(file);\n    return validated as FileType;\n  } catch(error) {\n    if(error instanceof z.ZodError) {\n      const fieldErrors = error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');\n      throw new FileValidationError(`File validation failed: ${fieldErrors}`);\n    }\n    throw error;\n  }\n};\n\nexport const formatFileOutput = (file: FileType): FileType => file;\n\nexport const getFileType = (file: FileType): string | undefined => {\n  const {fileType, name} = file;\n\n  if(fileType) {\n    return parseString(fileType, 16);\n  }\n\n  const nameArr: string[] = name?.split('.') || [];\n  const ext: string = nameArr.length && nameArr[nameArr.length - 1] || '';\n\n  switch(ext) {\n    case 'jpeg':\n    case 'jpg':\n      return 'image/jpeg';\n    case 'png':\n      return 'image/png';\n    case 'zip':\n      return 'application/zip';\n    default:\n      return undefined;\n  }\n};\n\nexport const parseFile = (file: FileType): FileType => {\n  try {\n    const parsed = performFileTransformation(file);\n    return parsed;\n  } catch(error) {\n    if(error instanceof FileValidationError) {\n      throw error;\n    }\n    throw new FileValidationError(`File parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n  }\n};\n\nconst performFileTransformation = (file: FileType): FileType => {\n  const {\n    _id,\n    _key,\n    base64,\n    buffer,\n    description,\n    fileId,\n    fileSize,\n    fileType,\n    id,\n    itemId,\n    itemType,\n    name,\n    url,\n    userId\n  } = file;\n\n  const transformed = {\n    ...parseDocument(file),\n    ...(base64 && {base64}),\n    ...(buffer && {buffer}),\n    ...(description && {description: parseReaktorContent(description)}),\n    ...((_key || fileId) && {fileId: parseId(_key || fileId)}),\n    ...((_id || id || _key || fileId) && {id: parseArangoId(_id || id || `files/${_key || fileId}`)}),\n    ...(fileSize !== undefined && {fileSize: parseNum(fileSize)}),\n    ...(fileType && {fileType: getFileType(file)}),\n    ...(itemId && {itemId: parseId(itemId)}),\n    ...(itemType && {itemType: parseReaktorType(itemType)}),\n    ...(name && {name: parseString(name, 160)}),\n    ...(url && {url: parseUrl(url)}),\n    ...(userId && {userId: parseId(userId)})\n  };\n\n  return transformed;\n};"],"names":["parseNum","parseArangoId","parseId","parseString","parseUrl","z","parseDocument","parseReaktorContent","parseReaktorType","FileValidationError","Error","message","field","name","FileInputSchema","object","_from","string","optional","_id","_key","_oldRev","_rev","_to","base64","buffer","any","description","fileId","fileSize","number","fileType","itemId","itemType","url","userId","passthrough","validateFileInput","file","validated","parse","error","ZodError","fieldErrors","issues","map","e","path","join","formatFileOutput","getFileType","nameArr","split","ext","length","undefined","parseFile","parsed","performFileTransformation","id","transformed"],"mappings":"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"}

package/lib/adapters/imageAdapter.d.ts

@@ -6,3 +6,4 @@ export declare class ImageValidationError extends Error {
 export declare const validateImageInput: (image: unknown) => ImageType;
 export declare const formatImageOutput: (image: ImageType) => ImageType;
 export declare const parseImage: (image: ImageType) => ImageType;
+//# sourceMappingURL=imageAdapter.d.ts.map

package/lib/adapters/imageAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/imageAdapter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAC;AAExD,qBAAa,oBAAqB,SAAQ,KAAK;IACT,KAAK,CAAC,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,MAAM;CAInD;AAyBD,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,SAWnD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,KAAG,SAAkB,CAAC;AAExE,eAAO,MAAM,UAAU,GAAI,OAAO,SAAS,KAAG,SAU7C,CAAC"}