@nlabs/metropolisjs 0.1.2 → 0.3.0

package/lib/adapters/videoAdapter/videoAdapter.js

@@ -0,0 +1,194 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseArangoId, parseId, parseNum, parseString } from '@nlabs/utils';
+import { z } from 'zod';
+import { parseDocument, removeEmptyKeys } from '../arangoAdapter/arangoAdapter.js';
+import { parseReaktorItemId } from '../reaktorAdapter/reaktorAdapter.js';
+export class VideoValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'VideoValidationError';
+    }
+}
+const VideoInputSchema = z.object({
+    _id: z.string().optional(),
+    _key: z.string().optional(),
+    base64: z.string().optional(),
+    description: z.string().optional(),
+    duration: z.number().optional(),
+    externalId: z.string().optional(),
+    externalUrl: z.string().optional(),
+    fileName: z.string().optional(),
+    fileSize: z.number().optional(),
+    fileType: z.string().optional(),
+    format: z.string().optional(),
+    height: z.number().optional(),
+    hlsUrl: z.string().optional(),
+    itemId: z.string().optional(),
+    itemType: z.string().optional(),
+    mediaConvertJobId: z.string().optional(),
+    mimeType: z.string().optional(),
+    name: z.string().optional(),
+    playbackFileType: z.string().optional(),
+    playbackUrl: z.string().optional(),
+    privacy: z.string().optional(),
+    provider: z.string().optional(),
+    processingError: z.string().optional(),
+    processingStatus: z.string().optional(),
+    size: z.number().optional(),
+    sourceKey: z.string().optional(),
+    streamType: z.string().optional(),
+    thumbBase64: z.string().optional(),
+    thumbFileType: z.string().optional(),
+    thumbUrl: z.string().optional(),
+    type: z.string().optional(),
+    uploadId: z.string().optional(),
+    uploadKey: z.string().optional(),
+    uploadStatus: z.string().optional(),
+    url: z.string().optional(),
+    userId: z.string().optional(),
+    videoId: z.string().optional(),
+    width: z.number().optional()
+}).loose();
+export const validateVideoInput = (video)=>{
+    try {
+        const validated = VideoInputSchema.parse(video);
+        return validated;
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const fieldErrors = error.issues.map((e)=>`${e.path.join('.')}: ${e.message}`).join(', ');
+            throw new VideoValidationError(`Video validation failed: ${fieldErrors}`);
+        }
+        throw error;
+    }
+};
+export const parseVideo = (video)=>{
+    try {
+        const parsed = performVideoTransformation(video);
+        return parsed;
+    } catch (error) {
+        if (error instanceof VideoValidationError) {
+            throw error;
+        }
+        throw new VideoValidationError(`Video parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+const performVideoTransformation = (video)=>{
+    const { _id, _key, base64, description, duration, externalId, externalUrl, fileName, fileSize, fileType, format, height, hlsUrl, itemId, itemType, mediaConvertJobId, mimeType, name, playbackFileType, playbackUrl, privacy, provider, processingError, processingStatus, size, sourceKey, streamType, thumbBase64, thumbFileType, thumbUrl, url, uploadId, uploadKey, uploadStatus, userId, videoId, width } = video;
+    const transformed = removeEmptyKeys({
+        ...parseDocument(video),
+        ...base64 && {
+            base64: parseString(base64, 100000000)
+        },
+        ...description && {
+            description: parseString(description, 1000)
+        },
+        ...duration !== undefined && {
+            duration: parseNum(duration)
+        },
+        ...externalId && {
+            externalId: parseString(externalId, 255)
+        },
+        ...externalUrl && {
+            externalUrl: parseString(externalUrl, 500)
+        },
+        ...fileName && {
+            fileName: parseString(fileName, 255)
+        },
+        ...fileSize !== undefined && {
+            fileSize: parseNum(fileSize)
+        },
+        ...fileType && {
+            fileType: parseString(fileType, 100)
+        },
+        ...format && {
+            format: parseString(format, 50)
+        },
+        ...height !== undefined && {
+            height: parseNum(height)
+        },
+        ...hlsUrl && {
+            hlsUrl: parseString(hlsUrl, 4096)
+        },
+        ...(_id || _key || videoId) && {
+            id: parseArangoId(_id || `videos/${_key || videoId}`)
+        },
+        ...itemId && {
+            itemId: parseReaktorItemId(itemId)
+        },
+        ...itemType && {
+            itemType: parseString(itemType, 32)
+        },
+        ...mediaConvertJobId && {
+            mediaConvertJobId: parseString(mediaConvertJobId, 128)
+        },
+        ...mimeType && {
+            mimeType: parseString(mimeType, 100)
+        },
+        ...name && {
+            name: parseString(name, 255)
+        },
+        ...playbackFileType && {
+            playbackFileType: parseString(playbackFileType, 100)
+        },
+        ...playbackUrl && {
+            playbackUrl: parseString(playbackUrl, 4096)
+        },
+        ...privacy && {
+            privacy: parseString(privacy, 32)
+        },
+        ...provider && {
+            provider: parseString(provider, 50)
+        },
+        ...processingError && {
+            processingError: parseString(processingError, 1000)
+        },
+        ...processingStatus && {
+            processingStatus: parseString(processingStatus, 64)
+        },
+        ...size !== undefined && {
+            size: parseNum(size)
+        },
+        ...sourceKey && {
+            sourceKey: parseString(sourceKey, 2000)
+        },
+        ...streamType && {
+            streamType: parseString(streamType, 64)
+        },
+        ...thumbBase64 && {
+            thumbBase64: parseString(thumbBase64, 10000000)
+        },
+        ...thumbFileType && {
+            thumbFileType: parseString(thumbFileType, 100)
+        },
+        ...thumbUrl && {
+            thumbUrl: parseString(thumbUrl, 4096)
+        },
+        ...url && {
+            url: parseString(url, 4096)
+        },
+        ...uploadId && {
+            uploadId: parseString(uploadId, 2048)
+        },
+        ...uploadKey && {
+            uploadKey: parseString(uploadKey, 2000)
+        },
+        ...uploadStatus && {
+            uploadStatus: parseString(uploadStatus, 64)
+        },
+        ...userId && {
+            userId: parseId(userId)
+        },
+        ...(_key || videoId) && {
+            videoId: parseId(_key || videoId || '')
+        },
+        ...width !== undefined && {
+            width: parseNum(width)
+        }
+    });
+    return transformed;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/adapters/videoAdapter/videoAdapter.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 {parseArangoId, parseId, parseNum, parseString} from '@nlabs/utils';\nimport {z} from 'zod';\n\nimport {parseDocument, removeEmptyKeys} from '../arangoAdapter/arangoAdapter.js';\nimport {parseReaktorDate, parseReaktorItemId} from '../reaktorAdapter/reaktorAdapter.js';\n\nimport type {VideoType} from '../../types/videos.types.js';\n\nexport class VideoValidationError extends Error {\n  constructor(message: string, public field?: string) {\n    super(message);\n    this.name = 'VideoValidationError';\n  }\n}\n\nconst VideoInputSchema = z.object({\n  _id: z.string().optional(),\n  _key: z.string().optional(),\n  base64: z.string().optional(),\n  description: z.string().optional(),\n  duration: z.number().optional(),\n  externalId: z.string().optional(),\n  externalUrl: z.string().optional(),\n  fileName: z.string().optional(),\n  fileSize: z.number().optional(),\n  fileType: z.string().optional(),\n  format: z.string().optional(),\n  height: z.number().optional(),\n  hlsUrl: z.string().optional(),\n  itemId: z.string().optional(),\n  itemType: z.string().optional(),\n  mediaConvertJobId: z.string().optional(),\n  mimeType: z.string().optional(),\n  name: z.string().optional(),\n  playbackFileType: z.string().optional(),\n  playbackUrl: z.string().optional(),\n  privacy: z.string().optional(),\n  provider: z.string().optional(),\n  processingError: z.string().optional(),\n  processingStatus: z.string().optional(),\n  size: z.number().optional(),\n  sourceKey: z.string().optional(),\n  streamType: z.string().optional(),\n  thumbBase64: z.string().optional(),\n  thumbFileType: z.string().optional(),\n  thumbUrl: z.string().optional(),\n  type: z.string().optional(),\n  uploadId: z.string().optional(),\n  uploadKey: z.string().optional(),\n  uploadStatus: z.string().optional(),\n  url: z.string().optional(),\n  userId: z.string().optional(),\n  videoId: z.string().optional(),\n  width: z.number().optional()\n}).loose();\n\nexport const validateVideoInput = (video: unknown): VideoType => {\n  try {\n    const validated = VideoInputSchema.parse(video);\n    return validated as VideoType;\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 VideoValidationError(`Video validation failed: ${fieldErrors}`);\n    }\n    throw error;\n  }\n};\n\nexport const parseVideo = (video: VideoType): VideoType => {\n  try {\n    const parsed = performVideoTransformation(video);\n    return parsed;\n  } catch(error) {\n    if(error instanceof VideoValidationError) {\n      throw error;\n    }\n    throw new VideoValidationError(`Video parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n  }\n};\n\nconst performVideoTransformation = (video: VideoType): VideoType => {\n  const {\n    _id,\n    _key,\n    base64,\n    description,\n    duration,\n    externalId,\n    externalUrl,\n    fileName,\n    fileSize,\n    fileType,\n    format,\n    height,\n    hlsUrl,\n    itemId,\n    itemType,\n    mediaConvertJobId,\n    mimeType,\n    name,\n    playbackFileType,\n    playbackUrl,\n    privacy,\n    provider,\n    processingError,\n    processingStatus,\n    size,\n    sourceKey,\n    streamType,\n    thumbBase64,\n    thumbFileType,\n    thumbUrl,\n    url,\n    uploadId,\n    uploadKey,\n    uploadStatus,\n    userId,\n    videoId,\n    width\n  } = video;\n\n  const transformed = removeEmptyKeys({\n    ...parseDocument(video),\n    ...(base64 && {base64: parseString(base64, 100000000)}),\n    ...(description && {description: parseString(description, 1000)}),\n    ...(duration !== undefined && {duration: parseNum(duration)}),\n    ...(externalId && {externalId: parseString(externalId, 255)}),\n    ...(externalUrl && {externalUrl: parseString(externalUrl, 500)}),\n    ...(fileName && {fileName: parseString(fileName, 255)}),\n    ...(fileSize !== undefined && {fileSize: parseNum(fileSize)}),\n    ...(fileType && {fileType: parseString(fileType, 100)}),\n    ...(format && {format: parseString(format, 50)}),\n    ...(height !== undefined && {height: parseNum(height)}),\n    ...(hlsUrl && {hlsUrl: parseString(hlsUrl, 4096)}),\n    ...((_id || _key || videoId) && {id: parseArangoId(_id || `videos/${_key || videoId}`)}),\n    ...(itemId && {itemId: parseReaktorItemId(itemId)}),\n    ...(itemType && {itemType: parseString(itemType, 32)}),\n    ...(mediaConvertJobId && {mediaConvertJobId: parseString(mediaConvertJobId, 128)}),\n    ...(mimeType && {mimeType: parseString(mimeType, 100)}),\n    ...(name && {name: parseString(name, 255)}),\n    ...(playbackFileType && {playbackFileType: parseString(playbackFileType, 100)}),\n    ...(playbackUrl && {playbackUrl: parseString(playbackUrl, 4096)}),\n    ...(privacy && {privacy: parseString(privacy, 32)}),\n    ...(provider && {provider: parseString(provider, 50)}),\n    ...(processingError && {processingError: parseString(processingError, 1000)}),\n    ...(processingStatus && {processingStatus: parseString(processingStatus, 64)}),\n    ...(size !== undefined && {size: parseNum(size)}),\n    ...(sourceKey && {sourceKey: parseString(sourceKey, 2000)}),\n    ...(streamType && {streamType: parseString(streamType, 64)}),\n    ...(thumbBase64 && {thumbBase64: parseString(thumbBase64, 10000000)}),\n    ...(thumbFileType && {thumbFileType: parseString(thumbFileType, 100)}),\n    ...(thumbUrl && {thumbUrl: parseString(thumbUrl, 4096)}),\n    ...(url && {url: parseString(url, 4096)}),\n    ...(uploadId && {uploadId: parseString(uploadId, 2048)}),\n    ...(uploadKey && {uploadKey: parseString(uploadKey, 2000)}),\n    ...(uploadStatus && {uploadStatus: parseString(uploadStatus, 64)}),\n    ...(userId && {userId: parseId(userId)}),\n    ...((_key || videoId) && {videoId: parseId(_key || videoId || '')}),\n    ...(width !== undefined && {width: parseNum(width)})\n  });\n\n  return transformed;\n};\n"],"names":["parseArangoId","parseId","parseNum","parseString","z","parseDocument","removeEmptyKeys","parseReaktorItemId","VideoValidationError","Error","message","field","name","VideoInputSchema","object","_id","string","optional","_key","base64","description","duration","number","externalId","externalUrl","fileName","fileSize","fileType","format","height","hlsUrl","itemId","itemType","mediaConvertJobId","mimeType","playbackFileType","playbackUrl","privacy","provider","processingError","processingStatus","size","sourceKey","streamType","thumbBase64","thumbFileType","thumbUrl","type","uploadId","uploadKey","uploadStatus","url","userId","videoId","width","loose","validateVideoInput","video","validated","parse","error","ZodError","fieldErrors","issues","map","e","path","join","parseVideo","parsed","performVideoTransformation","transformed","undefined","id"],"mappings":"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"}

package/lib/config/index.d.ts

@@ -1,7 +1,8 @@
-import type { MetropolisAdapters } from '../utils/MetropolisProvider';
+import type { MetropolisAdapters } from '../utils/MetropolisProvider.js';
 export interface ConfigAppSessionType {
     readonly maxMinutes?: number;
     readonly minMinutes?: number;
+    readonly refreshAfterRatio?: number;
 }
 export interface ConfigAppUrls {
     readonly websocket?: string;
@@ -19,13 +20,25 @@ export interface ConfigAppType {
     readonly version?: string;
 }
 export interface MetropolisConfiguration {
+    readonly local?: MetropolisEnvironmentConfiguration;
+    readonly development?: MetropolisEnvironmentConfiguration;
+    readonly production?: MetropolisEnvironmentConfiguration;
+    readonly test?: MetropolisEnvironmentConfiguration;
+}
+export interface MetropolisEnvironmentConfiguration {
     readonly adapters?: MetropolisAdapters;
     readonly app?: Partial<ConfigAppType>;
     readonly environment?: string;
     readonly isAuth?: () => boolean;
 }
-export declare class Config {
-    static values: Record<string, unknown>;
-    static setConfig(values: MetropolisConfiguration): MetropolisConfiguration;
-    static get<T = unknown>(path?: string | string[], defaultValue?: T): T;
-}
+/**
+ * Gets the default configuration for a specific environment.
+ */
+export declare const getDefaultConfig: (environment?: string) => MetropolisEnvironmentConfiguration;
+/**
+ * Resolves the environment-specific configuration from a MetropolisConfiguration object.
+ * This function determines which environment to use based on process.env and merges
+ * the appropriate configuration.
+ */
+export declare const resolveEnvironmentConfig: (config: MetropolisConfiguration, environment?: string) => MetropolisEnvironmentConfiguration;
+//# sourceMappingURL=index.d.ts.map

package/lib/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAEvE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CACrC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,oBAAoB,CAAC;IACxC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,CAAC,EAAE,kCAAkC,CAAC;IACpD,QAAQ,CAAC,WAAW,CAAC,EAAE,kCAAkC,CAAC;IAC1D,QAAQ,CAAC,UAAU,CAAC,EAAE,kCAAkC,CAAC;IACzD,QAAQ,CAAC,IAAI,CAAC,EAAE,kCAAkC,CAAC;CACpD;AAED,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC;CACjC;AAgED;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,cAAc,MAAM,KAAG,kCAKvD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,QAAQ,uBAAuB,EAC/B,cAAc,MAAM,KACnB,kCAuBF,CAAC"}

package/lib/config/index.js

@@ -1,2 +1,97 @@
-import{get as i,merge as t}from"@nlabs/utils";class a{static values={};static setConfig(e){return this.values=t(this.values,e),this.values}static get(e,o){const r=process.env.NODE_ENV||"development",n={...this.values,environment:r};return e?i(n,e,o):n}}export{a as Config};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2NvbmZpZy9pbmRleC50c3giXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE4LVByZXNlbnQsIE5pdHJvZ2VuIExhYnMsIEluYy5cbiAqIENvcHlyaWdodHMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLiBTZWUgdGhlIGFjY29tcGFueWluZyBMSUNFTlNFIGZpbGUgZm9yIHRlcm1zLlxuICovXG5pbXBvcnQge2dldCwgbWVyZ2V9IGZyb20gJ0BubGFicy91dGlscyc7XG5cbmltcG9ydCB0eXBlIHtNZXRyb3BvbGlzQWRhcHRlcnN9IGZyb20gJy4uL3V0aWxzL01ldHJvcG9saXNQcm92aWRlcic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29uZmlnQXBwU2Vzc2lvblR5cGUge1xuICByZWFkb25seSBtYXhNaW51dGVzPzogbnVtYmVyO1xuICByZWFkb25seSBtaW5NaW51dGVzPzogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENvbmZpZ0FwcFVybHMge1xuICByZWFkb25seSB3ZWJzb2NrZXQ/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29uZmlnQXBwQXBpVHlwZSB7XG4gIHJlYWRvbmx5IHB1YmxpYz86IHN0cmluZztcbiAgcmVhZG9ubHkgdXJsPzogc3RyaW5nO1xuICByZWFkb25seSB1cGxvYWRJbWFnZT86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb25maWdBcHBUeXBlIHtcbiAgcmVhZG9ubHkgYXBpPzogQ29uZmlnQXBwQXBpVHlwZTtcbiAgcmVhZG9ubHkgbmFtZT86IHN0cmluZztcbiAgcmVhZG9ubHkgc2Vzc2lvbj86IENvbmZpZ0FwcFNlc3Npb25UeXBlO1xuICByZWFkb25seSB1cmxzPzogQ29uZmlnQXBwVXJscztcbiAgcmVhZG9ubHkgdmVyc2lvbj86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBNZXRyb3BvbGlzQ29uZmlndXJhdGlvbiB7XG4gIHJlYWRvbmx5IGFkYXB0ZXJzPzogTWV0cm9wb2xpc0FkYXB0ZXJzO1xuICByZWFkb25seSBhcHA/OiBQYXJ0aWFsPENvbmZpZ0FwcFR5cGU+O1xuICByZWFkb25seSBlbnZpcm9ubWVudD86IHN0cmluZztcbiAgcmVhZG9ubHkgaXNBdXRoPzogKCkgPT4gYm9vbGVhbjtcbn1cblxuZXhwb3J0IGNsYXNzIENvbmZpZyB7XG4gIHN0YXRpYyB2YWx1ZXM6IFJlY29yZDxzdHJpbmcsIHVua25vd24+ID0ge307XG5cbiAgc3RhdGljIHNldENvbmZpZyh2YWx1ZXM6IE1ldHJvcG9saXNDb25maWd1cmF0aW9uKTogTWV0cm9wb2xpc0NvbmZpZ3VyYXRpb24ge1xuICAgIHRoaXMudmFsdWVzID0gbWVyZ2UodGhpcy52YWx1ZXMsIHZhbHVlcyk7XG4gICAgcmV0dXJuIHRoaXMudmFsdWVzO1xuICB9XG5cbiAgc3RhdGljIGdldDxUID0gdW5rbm93bj4ocGF0aD86IHN0cmluZyB8IHN0cmluZ1tdLCBkZWZhdWx0VmFsdWU/OiBUKTogVCB7XG4gICAgY29uc3QgZW52aXJvbm1lbnQ6IHN0cmluZyA9IHByb2Nlc3MuZW52Lk5PREVfRU5WIHx8ICdkZXZlbG9wbWVudCc7XG4gICAgY29uc3QgY29uZmlnVmFsdWVzOiBNZXRyb3BvbGlzQ29uZmlndXJhdGlvbiA9IHsuLi50aGlzLnZhbHVlcywgZW52aXJvbm1lbnR9O1xuXG4gICAgaWYoIXBhdGgpIHtcbiAgICAgIHJldHVybiBjb25maWdWYWx1ZXMgYXMgVDtcbiAgICB9XG5cbiAgICByZXR1cm4gZ2V0KGNvbmZpZ1ZhbHVlcywgcGF0aCwgZGVmYXVsdFZhbHVlKSBhcyBUO1xuICB9XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUFJQSxPQUFRLE9BQUFBLEVBQUssU0FBQUMsTUFBWSxlQWtDbEIsTUFBTUMsQ0FBTyxDQUNsQixPQUFPLE9BQWtDLENBQUMsRUFFMUMsT0FBTyxVQUFVQyxFQUEwRCxDQUN6RSxZQUFLLE9BQVNGLEVBQU0sS0FBSyxPQUFRRSxDQUFNLEVBQ2hDLEtBQUssTUFDZCxDQUVBLE9BQU8sSUFBaUJDLEVBQTBCQyxFQUFxQixDQUNyRSxNQUFNQyxFQUFzQixRQUFRLElBQUksVUFBWSxjQUM5Q0MsRUFBd0MsQ0FBQyxHQUFHLEtBQUssT0FBUSxZQUFBRCxDQUFXLEVBRTFFLE9BQUlGLEVBSUdKLEVBQUlPLEVBQWNILEVBQU1DLENBQVksRUFIbENFLENBSVgsQ0FDRiIsCiAgIm5hbWVzIjogWyJnZXQiLCAibWVyZ2UiLCAiQ29uZmlnIiwgInZhbHVlcyIsICJwYXRoIiwgImRlZmF1bHRWYWx1ZSIsICJlbnZpcm9ubWVudCIsICJjb25maWdWYWx1ZXMiXQp9Cg==
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { merge } from '@nlabs/utils';
+/**
+ * Default configuration values for all environments.
+ */ const DEFAULT_CONFIG = {
+    development: {
+        app: {
+            api: {
+                public: 'http://localhost:3000/public',
+                url: 'http://localhost:3000/app'
+            },
+            session: {
+                maxMinutes: 15,
+                minMinutes: 5
+            }
+        },
+        environment: 'development',
+        isAuth: ()=>true
+    },
+    local: {
+        app: {
+            api: {
+                public: 'https://dev-api.torch.one/public',
+                url: 'https://dev-api.torch.one/app'
+            },
+            session: {
+                maxMinutes: 15,
+                minMinutes: 5
+            }
+        },
+        environment: 'local',
+        isAuth: ()=>true
+    },
+    production: {
+        app: {
+            api: {
+                public: 'https://api.torch.one/public',
+                url: 'https://api.torch.one/app'
+            },
+            session: {
+                maxMinutes: 15,
+                minMinutes: 5
+            }
+        },
+        environment: 'production',
+        isAuth: ()=>true
+    },
+    test: {
+        app: {
+            api: {
+                public: 'http://localhost:3000/public',
+                url: 'http://localhost:3000/app'
+            },
+            session: {
+                maxMinutes: 15,
+                minMinutes: 5
+            }
+        },
+        environment: 'test',
+        isAuth: ()=>true
+    }
+};
+/**
+ * Gets the default configuration for a specific environment.
+ */ export const getDefaultConfig = (environment)=>{
+    const targetEnvironment = environment || process.env.stage || process.env.NODE_ENV || 'local';
+    const envConfig = DEFAULT_CONFIG[targetEnvironment] || DEFAULT_CONFIG.local || {};
+    const localConfig = DEFAULT_CONFIG.local || {};
+    return merge({}, localConfig, envConfig);
+};
+/**
+ * Resolves the environment-specific configuration from a MetropolisConfiguration object.
+ * This function determines which environment to use based on process.env and merges
+ * the appropriate configuration.
+ */ export const resolveEnvironmentConfig = (config, environment)=>{
+    const targetEnvironment = environment || process.env.stage || process.env.NODE_ENV || 'local';
+    const baseConfig = DEFAULT_CONFIG;
+    // Merge base config with provided config
+    const mergedConfig = merge({}, baseConfig, config);
+    // Get the target environment config
+    const envConfig = mergedConfig[targetEnvironment] || mergedConfig.local || {};
+    // Merge with local as fallback
+    const localConfig = mergedConfig.local || {};
+    const resolved = merge({}, localConfig, envConfig);
+    // Ensure environment is set (create new object to avoid mutating readonly)
+    if (!resolved.environment) {
+        return {
+            ...resolved,
+            environment: targetEnvironment
+        };
+    }
+    return resolved;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/config/index.tsx"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {merge} from '@nlabs/utils';\n\nimport type {MetropolisAdapters} from '../utils/MetropolisProvider.js';\n\nexport interface ConfigAppSessionType {\n  readonly maxMinutes?: number;\n  readonly minMinutes?: number;\n  readonly refreshAfterRatio?: number;\n}\n\nexport interface ConfigAppUrls {\n  readonly websocket?: string;\n}\n\nexport interface ConfigAppApiType {\n  readonly public?: string;\n  readonly url?: string;\n  readonly uploadImage?: string;\n}\n\nexport interface ConfigAppType {\n  readonly api?: ConfigAppApiType;\n  readonly name?: string;\n  readonly session?: ConfigAppSessionType;\n  readonly urls?: ConfigAppUrls;\n  readonly version?: string;\n}\n\nexport interface MetropolisConfiguration {\n  readonly local?: MetropolisEnvironmentConfiguration;\n  readonly development?: MetropolisEnvironmentConfiguration;\n  readonly production?: MetropolisEnvironmentConfiguration;\n  readonly test?: MetropolisEnvironmentConfiguration;\n}\n\nexport interface MetropolisEnvironmentConfiguration {\n  readonly adapters?: MetropolisAdapters;\n  readonly app?: Partial<ConfigAppType>;\n  readonly environment?: string;\n  readonly isAuth?: () => boolean;\n}\n\n/**\n * Default configuration values for all environments.\n */\nconst DEFAULT_CONFIG: MetropolisConfiguration = {\n  development: {\n    app: {\n      api: {\n        public: 'http://localhost:3000/public',\n        url: 'http://localhost:3000/app'\n      },\n      session: {\n        maxMinutes: 15,\n        minMinutes: 5\n      }\n    },\n    environment: 'development',\n    isAuth: () => true\n  },\n  local: {\n    app: {\n      api: {\n        public: 'https://dev-api.torch.one/public',\n        url: 'https://dev-api.torch.one/app'\n      },\n      session: {\n        maxMinutes: 15,\n        minMinutes: 5\n      }\n    },\n    environment: 'local',\n    isAuth: () => true\n  },\n  production: {\n    app: {\n      api: {\n        public: 'https://api.torch.one/public',\n        url: 'https://api.torch.one/app'\n      },\n      session: {\n        maxMinutes: 15,\n        minMinutes: 5\n      }\n    },\n    environment: 'production',\n    isAuth: () => true\n  },\n  test: {\n    app: {\n      api: {\n        public: 'http://localhost:3000/public',\n        url: 'http://localhost:3000/app'\n      },\n      session: {\n        maxMinutes: 15,\n        minMinutes: 5\n      }\n    },\n    environment: 'test',\n    isAuth: () => true\n  }\n};\n\n/**\n * Gets the default configuration for a specific environment.\n */\nexport const getDefaultConfig = (environment?: string): MetropolisEnvironmentConfiguration => {\n  const targetEnvironment = environment || process.env.stage || process.env.NODE_ENV || 'local';\n  const envConfig = DEFAULT_CONFIG[targetEnvironment] || DEFAULT_CONFIG.local || {};\n  const localConfig = DEFAULT_CONFIG.local || {};\n  return merge({}, localConfig, envConfig);\n};\n\n/**\n * Resolves the environment-specific configuration from a MetropolisConfiguration object.\n * This function determines which environment to use based on process.env and merges\n * the appropriate configuration.\n */\nexport const resolveEnvironmentConfig = (\n  config: MetropolisConfiguration,\n  environment?: string\n): MetropolisEnvironmentConfiguration => {\n  const targetEnvironment = environment || process.env.stage || process.env.NODE_ENV || 'local';\n  const baseConfig = DEFAULT_CONFIG;\n\n  // Merge base config with provided config\n  const mergedConfig = merge({}, baseConfig, config);\n\n  // Get the target environment config\n  const envConfig = mergedConfig[targetEnvironment] || mergedConfig.local || {};\n\n  // Merge with local as fallback\n  const localConfig = mergedConfig.local || {};\n  const resolved = merge({}, localConfig, envConfig);\n\n  // Ensure environment is set (create new object to avoid mutating readonly)\n  if (!resolved.environment) {\n    return {\n      ...resolved,\n      environment: targetEnvironment\n    };\n  }\n\n  return resolved;\n};\n"],"names":["merge","DEFAULT_CONFIG","development","app","api","public","url","session","maxMinutes","minMinutes","environment","isAuth","local","production","test","getDefaultConfig","targetEnvironment","process","env","stage","NODE_ENV","envConfig","localConfig","resolveEnvironmentConfig","config","baseConfig","mergedConfig","resolved"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,KAAK,QAAO,eAAe;AA0CnC;;CAEC,GACD,MAAMC,iBAA0C;IAC9CC,aAAa;QACXC,KAAK;YACHC,KAAK;gBACHC,QAAQ;gBACRC,KAAK;YACP;YACAC,SAAS;gBACPC,YAAY;gBACZC,YAAY;YACd;QACF;QACAC,aAAa;QACbC,QAAQ,IAAM;IAChB;IACAC,OAAO;QACLT,KAAK;YACHC,KAAK;gBACHC,QAAQ;gBACRC,KAAK;YACP;YACAC,SAAS;gBACPC,YAAY;gBACZC,YAAY;YACd;QACF;QACAC,aAAa;QACbC,QAAQ,IAAM;IAChB;IACAE,YAAY;QACVV,KAAK;YACHC,KAAK;gBACHC,QAAQ;gBACRC,KAAK;YACP;YACAC,SAAS;gBACPC,YAAY;gBACZC,YAAY;YACd;QACF;QACAC,aAAa;QACbC,QAAQ,IAAM;IAChB;IACAG,MAAM;QACJX,KAAK;YACHC,KAAK;gBACHC,QAAQ;gBACRC,KAAK;YACP;YACAC,SAAS;gBACPC,YAAY;gBACZC,YAAY;YACd;QACF;QACAC,aAAa;QACbC,QAAQ,IAAM;IAChB;AACF;AAEA;;CAEC,GACD,OAAO,MAAMI,mBAAmB,CAACL;IAC/B,MAAMM,oBAAoBN,eAAeO,QAAQC,GAAG,CAACC,KAAK,IAAIF,QAAQC,GAAG,CAACE,QAAQ,IAAI;IACtF,MAAMC,YAAYpB,cAAc,CAACe,kBAAkB,IAAIf,eAAeW,KAAK,IAAI,CAAC;IAChF,MAAMU,cAAcrB,eAAeW,KAAK,IAAI,CAAC;IAC7C,OAAOZ,MAAM,CAAC,GAAGsB,aAAaD;AAChC,EAAE;AAEF;;;;CAIC,GACD,OAAO,MAAME,2BAA2B,CACtCC,QACAd;IAEA,MAAMM,oBAAoBN,eAAeO,QAAQC,GAAG,CAACC,KAAK,IAAIF,QAAQC,GAAG,CAACE,QAAQ,IAAI;IACtF,MAAMK,aAAaxB;IAEnB,yCAAyC;IACzC,MAAMyB,eAAe1B,MAAM,CAAC,GAAGyB,YAAYD;IAE3C,oCAAoC;IACpC,MAAMH,YAAYK,YAAY,CAACV,kBAAkB,IAAIU,aAAad,KAAK,IAAI,CAAC;IAE5E,+BAA+B;IAC/B,MAAMU,cAAcI,aAAad,KAAK,IAAI,CAAC;IAC3C,MAAMe,WAAW3B,MAAM,CAAC,GAAGsB,aAAaD;IAExC,2EAA2E;IAC3E,IAAI,CAACM,SAASjB,WAAW,EAAE;QACzB,OAAO;YACL,GAAGiB,QAAQ;YACXjB,aAAaM;QACf;IACF;IAEA,OAAOW;AACT,EAAE"}

package/lib/constants/Collections.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2024-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+export declare const COLLECTIONS: {
+    readonly APPS: "apps";
+    readonly CONVERSATIONS: "conversations";
+    readonly FILES: "files";
+    readonly GROUPS: "groups";
+    readonly IMAGES: "images";
+    readonly MESSAGES: "messages";
+    readonly POSTS: "posts";
+    readonly PERSONAS: "personas";
+    readonly TAGS: "tags";
+    readonly USERS: "users";
+    readonly VIDEOS: "videos";
+};
+export type CollectionType = typeof COLLECTIONS[keyof typeof COLLECTIONS];
+export declare const EDGES: {
+    readonly HAS_CONNECTION: "hasConnection";
+    readonly HAS_CONVERSATION: "hasConversation";
+    readonly HAS_FILE: "hasFile";
+    readonly HAS_MEDIA: "hasMedia";
+    readonly HAS_REACTION: "hasReaction";
+    readonly IS_TAGGED: "isTagged";
+};
+export type EdgeType = typeof EDGES[keyof typeof EDGES];
+export declare const CONNECTION_TYPES: {
+    readonly ADMIN: "admin";
+    readonly BLOCKED: "blocked";
+    readonly FOLLOWER: "follower";
+    readonly FOLLOWING: "following";
+    readonly MEMBER: "member";
+};
+export type ConnectionType = typeof CONNECTION_TYPES[keyof typeof CONNECTION_TYPES];
+export declare const REACTION_TYPES: {
+    readonly DISLIKE: "dislike";
+    readonly LIKE: "like";
+    readonly PIN: "pin";
+    readonly RSVP: "rsvp";
+    readonly VIEW: "view";
+};
+export type ReactionType = typeof REACTION_TYPES[keyof typeof REACTION_TYPES];
+//# sourceMappingURL=Collections.d.ts.map

package/lib/constants/Collections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collections.d.ts","sourceRoot":"","sources":["../../src/constants/Collections.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;CAYd,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,OAAO,WAAW,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAE1E,eAAO,MAAM,KAAK;;;;;;;CAOR,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,OAAO,KAAK,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC;AAExD,eAAO,MAAM,gBAAgB;;;;;;CAMnB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,OAAO,gBAAgB,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAC;AAEpF,eAAO,MAAM,cAAc;;;;;;CAMjB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,OAAO,cAAc,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC"}

package/lib/constants/Collections.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2024-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export const COLLECTIONS = {
+    APPS: 'apps',
+    CONVERSATIONS: 'conversations',
+    FILES: 'files',
+    GROUPS: 'groups',
+    IMAGES: 'images',
+    MESSAGES: 'messages',
+    POSTS: 'posts',
+    PERSONAS: 'personas',
+    TAGS: 'tags',
+    USERS: 'users',
+    VIDEOS: 'videos'
+};
+export const EDGES = {
+    HAS_CONNECTION: 'hasConnection',
+    HAS_CONVERSATION: 'hasConversation',
+    HAS_FILE: 'hasFile',
+    HAS_MEDIA: 'hasMedia',
+    HAS_REACTION: 'hasReaction',
+    IS_TAGGED: 'isTagged'
+};
+export const CONNECTION_TYPES = {
+    ADMIN: 'admin',
+    BLOCKED: 'blocked',
+    FOLLOWER: 'follower',
+    FOLLOWING: 'following',
+    MEMBER: 'member'
+};
+export const REACTION_TYPES = {
+    DISLIKE: 'dislike',
+    LIKE: 'like',
+    PIN: 'pin',
+    RSVP: 'rsvp',
+    VIEW: 'view'
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constants/MetropolisConstants.d.ts

@@ -12,3 +12,4 @@ export declare const MetropolisConstants: {
     UPDATE_NOTIFICATIONS: string;
     UPDATE_SESSION: string;
 };
+//# sourceMappingURL=MetropolisConstants.d.ts.map

package/lib/constants/MetropolisConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetropolisConstants.d.ts","sourceRoot":"","sources":["../../src/constants/MetropolisConstants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;CAS/B,CAAC"}

package/lib/constants/MetropolisConstants.js

@@ -1,2 +1,15 @@
-const S={INITIALIZE:"METROPOLIS_APP_INITIALIZE",LOADING:"METROPOLIS_APP_LOADING",SIGNOUT:"METROPOLIS_APP_SIGNOUT",SUBSCRIBE_MESSAGES:"METROPOLIS_APP_SUBSCRIBE_MESSAGES",SUBSCRIBE_NOTIFICATIONS:"METROPOLIS_APP_SUBSCRIBE_NOTIFICATIONS",UPDATE_MESSAGES:"METROPOLIS_APP_UPDATE_MESSAGES",UPDATE_NOTIFICATIONS:"METROPOLIS_APP_UPDATE_NOTIFICATIONS",UPDATE_SESSION:"METROPOLIS_APP_UPDATE_SESSION"};export{S as MetropolisConstants};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2NvbnN0YW50cy9NZXRyb3BvbGlzQ29uc3RhbnRzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAyMS1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuXG5leHBvcnQgY29uc3QgTWV0cm9wb2xpc0NvbnN0YW50cyA9IHtcbiAgSU5JVElBTElaRTogJ01FVFJPUE9MSVNfQVBQX0lOSVRJQUxJWkUnLFxuICBMT0FESU5HOiAnTUVUUk9QT0xJU19BUFBfTE9BRElORycsXG4gIFNJR05PVVQ6ICdNRVRST1BPTElTX0FQUF9TSUdOT1VUJyxcbiAgU1VCU0NSSUJFX01FU1NBR0VTOiAnTUVUUk9QT0xJU19BUFBfU1VCU0NSSUJFX01FU1NBR0VTJyxcbiAgU1VCU0NSSUJFX05PVElGSUNBVElPTlM6ICdNRVRST1BPTElTX0FQUF9TVUJTQ1JJQkVfTk9USUZJQ0FUSU9OUycsXG4gIFVQREFURV9NRVNTQUdFUzogJ01FVFJPUE9MSVNfQVBQX1VQREFURV9NRVNTQUdFUycsXG4gIFVQREFURV9OT1RJRklDQVRJT05TOiAnTUVUUk9QT0xJU19BUFBfVVBEQVRFX05PVElGSUNBVElPTlMnLFxuICBVUERBVEVfU0VTU0lPTjogJ01FVFJPUE9MSVNfQVBQX1VQREFURV9TRVNTSU9OJ1xufTtcbiJdLAogICJtYXBwaW5ncyI6ICJBQUtPLE1BQU1BLEVBQXNCLENBQ2pDLFdBQVksNEJBQ1osUUFBUyx5QkFDVCxRQUFTLHlCQUNULG1CQUFvQixvQ0FDcEIsd0JBQXlCLHlDQUN6QixnQkFBaUIsaUNBQ2pCLHFCQUFzQixzQ0FDdEIsZUFBZ0IsK0JBQ2xCIiwKICAibmFtZXMiOiBbIk1ldHJvcG9saXNDb25zdGFudHMiXQp9Cg==
+/**
+ * Copyright (c) 2021-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export const MetropolisConstants = {
+    INITIALIZE: 'METROPOLIS_APP_INITIALIZE',
+    LOADING: 'METROPOLIS_APP_LOADING',
+    SIGNOUT: 'METROPOLIS_APP_SIGNOUT',
+    SUBSCRIBE_MESSAGES: 'METROPOLIS_APP_SUBSCRIBE_MESSAGES',
+    SUBSCRIBE_NOTIFICATIONS: 'METROPOLIS_APP_SUBSCRIBE_NOTIFICATIONS',
+    UPDATE_MESSAGES: 'METROPOLIS_APP_UPDATE_MESSAGES',
+    UPDATE_NOTIFICATIONS: 'METROPOLIS_APP_UPDATE_NOTIFICATIONS',
+    UPDATE_SESSION: 'METROPOLIS_APP_UPDATE_SESSION'
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvY29uc3RhbnRzL01ldHJvcG9saXNDb25zdGFudHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMjEtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cblxuZXhwb3J0IGNvbnN0IE1ldHJvcG9saXNDb25zdGFudHMgPSB7XG4gIElOSVRJQUxJWkU6ICdNRVRST1BPTElTX0FQUF9JTklUSUFMSVpFJyxcbiAgTE9BRElORzogJ01FVFJPUE9MSVNfQVBQX0xPQURJTkcnLFxuICBTSUdOT1VUOiAnTUVUUk9QT0xJU19BUFBfU0lHTk9VVCcsXG4gIFNVQlNDUklCRV9NRVNTQUdFUzogJ01FVFJPUE9MSVNfQVBQX1NVQlNDUklCRV9NRVNTQUdFUycsXG4gIFNVQlNDUklCRV9OT1RJRklDQVRJT05TOiAnTUVUUk9QT0xJU19BUFBfU1VCU0NSSUJFX05PVElGSUNBVElPTlMnLFxuICBVUERBVEVfTUVTU0FHRVM6ICdNRVRST1BPTElTX0FQUF9VUERBVEVfTUVTU0FHRVMnLFxuICBVUERBVEVfTk9USUZJQ0FUSU9OUzogJ01FVFJPUE9MSVNfQVBQX1VQREFURV9OT1RJRklDQVRJT05TJyxcbiAgVVBEQVRFX1NFU1NJT046ICdNRVRST1BPTElTX0FQUF9VUERBVEVfU0VTU0lPTidcbn07XG4iXSwibmFtZXMiOlsiTWV0cm9wb2xpc0NvbnN0YW50cyIsIklOSVRJQUxJWkUiLCJMT0FESU5HIiwiU0lHTk9VVCIsIlNVQlNDUklCRV9NRVNTQUdFUyIsIlNVQlNDUklCRV9OT1RJRklDQVRJT05TIiwiVVBEQVRFX01FU1NBR0VTIiwiVVBEQVRFX05PVElGSUNBVElPTlMiLCJVUERBVEVfU0VTU0lPTiJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBRUQsT0FBTyxNQUFNQSxzQkFBc0I7SUFDakNDLFlBQVk7SUFDWkMsU0FBUztJQUNUQyxTQUFTO0lBQ1RDLG9CQUFvQjtJQUNwQkMseUJBQXlCO0lBQ3pCQyxpQkFBaUI7SUFDakJDLHNCQUFzQjtJQUN0QkMsZ0JBQWdCO0FBQ2xCLEVBQUUifQ==

package/lib/graphql/message.d.ts

@@ -1,2 +1,3 @@
 export declare const MessageUpdate = "mutate MessageUpdate($message: MessageInput) {\n  onUpdateMessage(message: $message) {\n    added\n    content\n    from\n    modified\n    to\n  }\n}";
 export declare const MessageSubscription = "subscription MessageSubscription {\n  onUpdateMessage(message: $message) {\n    added\n    content\n    from\n    modified\n    to\n  }\n}";
+//# sourceMappingURL=message.d.ts.map

package/lib/graphql/message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/graphql/message.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,2JAQxB,CAAC;AAEH,eAAO,MAAM,mBAAmB,+IAQ9B,CAAC"}

package/lib/graphql/message.js

@@ -1,4 +1,4 @@
-const e=`mutate MessageUpdate($message: MessageInput) {
+export const MessageUpdate = `mutate MessageUpdate($message: MessageInput) {
   onUpdateMessage(message: $message) {
     added
     content
@@ -6,7 +6,8 @@ const e=`mutate MessageUpdate($message: MessageInput) {
     modified
     to
   }
-}`,s=`subscription MessageSubscription {
+}`;
+export const MessageSubscription = `subscription MessageSubscription {
   onUpdateMessage(message: $message) {
     added
     content
@@ -14,5 +15,6 @@ const e=`mutate MessageUpdate($message: MessageInput) {
     modified
     to
   }
-}`;export{s as MessageSubscription,e as MessageUpdate};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2dyYXBocWwvbWVzc2FnZS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0IGNvbnN0IE1lc3NhZ2VVcGRhdGUgPSBgbXV0YXRlIE1lc3NhZ2VVcGRhdGUoJG1lc3NhZ2U6IE1lc3NhZ2VJbnB1dCkge1xuICBvblVwZGF0ZU1lc3NhZ2UobWVzc2FnZTogJG1lc3NhZ2UpIHtcbiAgICBhZGRlZFxuICAgIGNvbnRlbnRcbiAgICBmcm9tXG4gICAgbW9kaWZpZWRcbiAgICB0b1xuICB9XG59YDtcblxuZXhwb3J0IGNvbnN0IE1lc3NhZ2VTdWJzY3JpcHRpb24gPSBgc3Vic2NyaXB0aW9uIE1lc3NhZ2VTdWJzY3JpcHRpb24ge1xuICBvblVwZGF0ZU1lc3NhZ2UobWVzc2FnZTogJG1lc3NhZ2UpIHtcbiAgICBhZGRlZFxuICAgIGNvbnRlbnRcbiAgICBmcm9tXG4gICAgbW9kaWZpZWRcbiAgICB0b1xuICB9XG59YDtcbiJdLAogICJtYXBwaW5ncyI6ICJBQUFPLE1BQU1BLEVBQWdCO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxHQVVoQkMsRUFBc0I7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTsiLAogICJuYW1lcyI6IFsiTWVzc2FnZVVwZGF0ZSIsICJNZXNzYWdlU3Vic2NyaXB0aW9uIl0KfQo=
+}`;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvZ3JhcGhxbC9tZXNzYWdlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBNZXNzYWdlVXBkYXRlID0gYG11dGF0ZSBNZXNzYWdlVXBkYXRlKCRtZXNzYWdlOiBNZXNzYWdlSW5wdXQpIHtcbiAgb25VcGRhdGVNZXNzYWdlKG1lc3NhZ2U6ICRtZXNzYWdlKSB7XG4gICAgYWRkZWRcbiAgICBjb250ZW50XG4gICAgZnJvbVxuICAgIG1vZGlmaWVkXG4gICAgdG9cbiAgfVxufWA7XG5cbmV4cG9ydCBjb25zdCBNZXNzYWdlU3Vic2NyaXB0aW9uID0gYHN1YnNjcmlwdGlvbiBNZXNzYWdlU3Vic2NyaXB0aW9uIHtcbiAgb25VcGRhdGVNZXNzYWdlKG1lc3NhZ2U6ICRtZXNzYWdlKSB7XG4gICAgYWRkZWRcbiAgICBjb250ZW50XG4gICAgZnJvbVxuICAgIG1vZGlmaWVkXG4gICAgdG9cbiAgfVxufWA7XG4iXSwibmFtZXMiOlsiTWVzc2FnZVVwZGF0ZSIsIk1lc3NhZ2VTdWJzY3JpcHRpb24iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBTUEsZ0JBQWdCLENBQUM7Ozs7Ozs7O0NBUTdCLENBQUMsQ0FBQztBQUVILE9BQU8sTUFBTUMsc0JBQXNCLENBQUM7Ozs7Ozs7O0NBUW5DLENBQUMsQ0FBQyJ9

package/lib/graphql/notification.d.ts

@@ -1,2 +1,3 @@
 export declare const NotificationUpdate = "mutate NotificationUpdate($notification: NotificationInput) {\n  onUpdateNotification(notification: $notification) {\n    added\n    content\n    from\n    modified\n    to\n  }\n}";
 export declare const NotificationSubscription = "subscription NotificationSubscription {\n  onUpdateNotification(notification: $notification) {\n    added\n    content\n    from\n    modified\n    to\n  }\n}";
+//# sourceMappingURL=notification.d.ts.map

package/lib/graphql/notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.d.ts","sourceRoot":"","sources":["../../src/graphql/notification.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,yLAQ7B,CAAC;AAEH,eAAO,MAAM,wBAAwB,mKAQnC,CAAC"}

package/lib/graphql/notification.js

@@ -1,4 +1,4 @@
-const i=`mutate NotificationUpdate($notification: NotificationInput) {
+export const NotificationUpdate = `mutate NotificationUpdate($notification: NotificationInput) {
   onUpdateNotification(notification: $notification) {
     added
     content
@@ -6,7 +6,8 @@ const i=`mutate NotificationUpdate($notification: NotificationInput) {
     modified
     to
   }
-}`,t=`subscription NotificationSubscription {
+}`;
+export const NotificationSubscription = `subscription NotificationSubscription {
   onUpdateNotification(notification: $notification) {
     added
     content
@@ -14,5 +15,6 @@ const i=`mutate NotificationUpdate($notification: NotificationInput) {
     modified
     to
   }
-}`;export{t as NotificationSubscription,i as NotificationUpdate};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2dyYXBocWwvbm90aWZpY2F0aW9uLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJleHBvcnQgY29uc3QgTm90aWZpY2F0aW9uVXBkYXRlID0gYG11dGF0ZSBOb3RpZmljYXRpb25VcGRhdGUoJG5vdGlmaWNhdGlvbjogTm90aWZpY2F0aW9uSW5wdXQpIHtcbiAgb25VcGRhdGVOb3RpZmljYXRpb24obm90aWZpY2F0aW9uOiAkbm90aWZpY2F0aW9uKSB7XG4gICAgYWRkZWRcbiAgICBjb250ZW50XG4gICAgZnJvbVxuICAgIG1vZGlmaWVkXG4gICAgdG9cbiAgfVxufWA7XG5cbmV4cG9ydCBjb25zdCBOb3RpZmljYXRpb25TdWJzY3JpcHRpb24gPSBgc3Vic2NyaXB0aW9uIE5vdGlmaWNhdGlvblN1YnNjcmlwdGlvbiB7XG4gIG9uVXBkYXRlTm90aWZpY2F0aW9uKG5vdGlmaWNhdGlvbjogJG5vdGlmaWNhdGlvbikge1xuICAgIGFkZGVkXG4gICAgY29udGVudFxuICAgIGZyb21cbiAgICBtb2RpZmllZFxuICAgIHRvXG4gIH1cbn1gO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQU8sTUFBTUEsRUFBcUI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEdBVXJCQyxFQUEyQjtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBOyIsCiAgIm5hbWVzIjogWyJOb3RpZmljYXRpb25VcGRhdGUiLCAiTm90aWZpY2F0aW9uU3Vic2NyaXB0aW9uIl0KfQo=
+}`;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvZ3JhcGhxbC9ub3RpZmljYXRpb24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IE5vdGlmaWNhdGlvblVwZGF0ZSA9IGBtdXRhdGUgTm90aWZpY2F0aW9uVXBkYXRlKCRub3RpZmljYXRpb246IE5vdGlmaWNhdGlvbklucHV0KSB7XG4gIG9uVXBkYXRlTm90aWZpY2F0aW9uKG5vdGlmaWNhdGlvbjogJG5vdGlmaWNhdGlvbikge1xuICAgIGFkZGVkXG4gICAgY29udGVudFxuICAgIGZyb21cbiAgICBtb2RpZmllZFxuICAgIHRvXG4gIH1cbn1gO1xuXG5leHBvcnQgY29uc3QgTm90aWZpY2F0aW9uU3Vic2NyaXB0aW9uID0gYHN1YnNjcmlwdGlvbiBOb3RpZmljYXRpb25TdWJzY3JpcHRpb24ge1xuICBvblVwZGF0ZU5vdGlmaWNhdGlvbihub3RpZmljYXRpb246ICRub3RpZmljYXRpb24pIHtcbiAgICBhZGRlZFxuICAgIGNvbnRlbnRcbiAgICBmcm9tXG4gICAgbW9kaWZpZWRcbiAgICB0b1xuICB9XG59YDtcbiJdLCJuYW1lcyI6WyJOb3RpZmljYXRpb25VcGRhdGUiLCJOb3RpZmljYXRpb25TdWJzY3JpcHRpb24iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBTUEscUJBQXFCLENBQUM7Ozs7Ozs7O0NBUWxDLENBQUMsQ0FBQztBQUVILE9BQU8sTUFBTUMsMkJBQTJCLENBQUM7Ozs7Ozs7O0NBUXhDLENBQUMsQ0FBQyJ9

package/lib/graphql/session.d.ts

@@ -1 +1,2 @@
 export declare const SessionSubscription = "subscription SessionSubscription {\n  onUpdateSession {\n    active\n    added\n    email\n    id\n    latitude\n    longitude\n    location\n    modified\n    phone\n    username\n    userAccess\n  }\n}";
+//# sourceMappingURL=session.d.ts.map

package/lib/graphql/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/graphql/session.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,gNAc9B,CAAC"}

package/lib/graphql/session.js

@@ -1,4 +1,4 @@
-const i=`subscription SessionSubscription {
+export const SessionSubscription = `subscription SessionSubscription {
   onUpdateSession {
     active
     added
@@ -12,5 +12,6 @@ const i=`subscription SessionSubscription {
     username
     userAccess
   }
-}`;export{i as SessionSubscription};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2dyYXBocWwvc2Vzc2lvbi50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0IGNvbnN0IFNlc3Npb25TdWJzY3JpcHRpb24gPSBgc3Vic2NyaXB0aW9uIFNlc3Npb25TdWJzY3JpcHRpb24ge1xuICBvblVwZGF0ZVNlc3Npb24ge1xuICAgIGFjdGl2ZVxuICAgIGFkZGVkXG4gICAgZW1haWxcbiAgICBpZFxuICAgIGxhdGl0dWRlXG4gICAgbG9uZ2l0dWRlXG4gICAgbG9jYXRpb25cbiAgICBtb2RpZmllZFxuICAgIHBob25lXG4gICAgdXNlcm5hbWVcbiAgICB1c2VyQWNjZXNzXG4gIH1cbn1gO1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQU8sTUFBTUEsRUFBc0I7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTsiLAogICJuYW1lcyI6IFsiU2Vzc2lvblN1YnNjcmlwdGlvbiJdCn0K
+}`;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvZ3JhcGhxbC9zZXNzaW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBTZXNzaW9uU3Vic2NyaXB0aW9uID0gYHN1YnNjcmlwdGlvbiBTZXNzaW9uU3Vic2NyaXB0aW9uIHtcbiAgb25VcGRhdGVTZXNzaW9uIHtcbiAgICBhY3RpdmVcbiAgICBhZGRlZFxuICAgIGVtYWlsXG4gICAgaWRcbiAgICBsYXRpdHVkZVxuICAgIGxvbmdpdHVkZVxuICAgIGxvY2F0aW9uXG4gICAgbW9kaWZpZWRcbiAgICBwaG9uZVxuICAgIHVzZXJuYW1lXG4gICAgdXNlckFjY2Vzc1xuICB9XG59YDtcbiJdLCJuYW1lcyI6WyJTZXNzaW9uU3Vic2NyaXB0aW9uIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLE1BQU1BLHNCQUFzQixDQUFDOzs7Ozs7Ozs7Ozs7OztDQWNuQyxDQUFDLENBQUMifQ==