@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/adapters/userAdapter/userAdapter.js

@@ -0,0 +1,302 @@
+import { parseArangoId, parseChar, parseEmail, parseId, parseNum, parseString, parseVarChar } from '@nlabs/utils';
+import { z } from 'zod';
+import { parseDocument, removeEmptyKeys } from '../arangoAdapter/arangoAdapter.js';
+import { parseReaktorDate, parseReaktorItemId, parseReaktorName, parseReaktorType } from '../reaktorAdapter/reaktorAdapter.js';
+export class UserValidationError extends Error {
+    field;
+    constructor(message, field){
+        super(message), this.field = field;
+        this.name = 'UserValidationError';
+    }
+}
+const UserInputSchema = z.object({
+    _id: z.string().optional(),
+    _key: z.string().optional(),
+    active: z.boolean().optional(),
+    added: z.number().optional(),
+    bankId: z.string().max(160).optional(),
+    city: z.string().max(160).optional(),
+    country: z.string().length(2).optional(),
+    currency: z.string().length(3).optional(),
+    deviceToken: z.string().max(160).optional(),
+    dob: z.number().optional(),
+    birthdate: z.number().optional(),
+    email: z.email().optional(),
+    firstName: z.string().max(160).optional(),
+    gender: z.string().length(1).optional(),
+    id: z.string().optional(),
+    imageId: z.string().optional(),
+    lastName: z.string().max(160).optional(),
+    lastActive: z.number().optional(),
+    locale: z.string().max(5).optional(),
+    mailingList: z.boolean().optional(),
+    name: z.string().max(160).optional(),
+    password: z.string().max(160).optional(),
+    phone: z.string().max(20).optional(),
+    planExpires: z.number().optional(),
+    planId: z.string().max(160).optional(),
+    planStatus: z.string().max(160).optional(),
+    planSubscriptionId: z.string().max(160).optional(),
+    salt: z.string().max(160).optional(),
+    state: z.string().length(2).optional(),
+    street1: z.string().max(160).optional(),
+    street2: z.string().max(160).optional(),
+    stripeAccountId: z.string().max(160).optional(),
+    stripeCardBrand: z.string().max(160).optional(),
+    stripeCardId: z.string().max(160).optional(),
+    stripeCardLast4: z.string().max(4).optional(),
+    stripeCustomerId: z.string().max(160).optional(),
+    timezone: z.string().max(160).optional(),
+    type: z.string().max(160).optional(),
+    updated: z.number().optional(),
+    userAccess: z.number().optional(),
+    userId: z.string().optional(),
+    username: z.string().max(160).optional(),
+    verifiedEmail: z.boolean().optional(),
+    verifiedEmailCode: z.number().optional(),
+    verifiedEmailExpires: z.number().optional(),
+    verifiedPhone: z.boolean().optional(),
+    verifiedPhoneExpires: z.number().optional(),
+    verifiedSmsCode: z.number().optional(),
+    zip: z.string().max(20).optional()
+}).loose();
+const validatePhone = (phone)=>{
+    if (!phone) {
+        return undefined;
+    }
+    const cleaned = phone.replace(/\D/g, '');
+    if (cleaned.length < 10 || cleaned.length > 15) {
+        throw new UserValidationError('Invalid phone number format', 'phone');
+    }
+    return `+${cleaned}`;
+};
+const validateCountry = (country)=>{
+    if (!country) {
+        return undefined;
+    }
+    const upper = country.toUpperCase();
+    if (!/^[A-Z]{2}$/.test(upper)) {
+        throw new UserValidationError('Country must be a 2-letter ISO code', 'country');
+    }
+    return upper;
+};
+const validateState = (state)=>{
+    if (!state) {
+        return undefined;
+    }
+    const upper = state.toUpperCase();
+    if (!/^[A-Z]{2}$/.test(upper)) {
+        throw new UserValidationError('State must be a 2-letter code', 'state');
+    }
+    return upper;
+};
+const validateGender = (gender)=>{
+    if (!gender) {
+        return undefined;
+    }
+    const upper = gender.toUpperCase();
+    if (!/^[MF]$/.test(upper)) {
+        throw new UserValidationError('Gender must be M or F', 'gender');
+    }
+    return upper;
+};
+const userCache = new Map();
+export const validateUserInput = (user)=>{
+    try {
+        const validated = UserInputSchema.parse(user);
+        return validated;
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            const fieldErrors = error.issues.map((e)=>`${e.path.join('.')}: ${e.message}`).join(', ');
+            throw new UserValidationError(`User validation failed: ${fieldErrors}`);
+        }
+        throw error;
+    }
+};
+export const formatUserOutput = (user)=>{
+    const { password, salt, verifiedEmailCode, verifiedSmsCode, ...safeUser } = user;
+    return safeUser;
+};
+export const parseUser = (user)=>{
+    try {
+        const parsed = performUserTransformation(user);
+        return parsed;
+    } catch (error) {
+        if (error instanceof UserValidationError) {
+            throw error;
+        }
+        throw new UserValidationError(`User parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+const performUserTransformation = (user)=>{
+    const { _id, _key, active, bankId, city, country, currency, deviceToken, dob, birthdate, email, firstName, gender, id, imageId, lastName, lastActive, locale, mailingList, name, password, phone, planExpires, planId, planStatus, planSubscriptionId, salt, state, street1, street2, stripeAccountId, stripeCardBrand, stripeCardId, stripeCardLast4, stripeCustomerId, timezone, type, userAccess, userId, username, verifiedEmail, verifiedEmailCode, verifiedEmailExpires, verifiedPhone, verifiedPhoneExpires, verifiedSmsCode, zip } = user;
+    const normalizedDob = birthdate ?? dob;
+    const normalizedFirst = firstName;
+    const normalizedLast = lastName;
+    const transformed = {
+        ...parseDocument(user),
+        ...(_id || id || _key || userId) && {
+            id: parseArangoId(_id || id || `users/${_key || userId}`)
+        },
+        ...(_key || userId) && {
+            userId: parseId(_key || userId || '')
+        },
+        ...active !== undefined && {
+            active: !!active
+        },
+        ...bankId && {
+            bankId: parseVarChar(bankId, 160)
+        },
+        ...city && {
+            city: parseVarChar(city, 160)
+        },
+        ...country && {
+            country: validateCountry(country)
+        },
+        ...currency && {
+            currency: parseChar(currency, 3).toUpperCase()
+        },
+        ...deviceToken && {
+            deviceToken: parseVarChar(deviceToken, 160)
+        },
+        ...normalizedDob !== undefined && {
+            birthdate: parseReaktorDate(normalizedDob),
+            dob: parseReaktorDate(normalizedDob)
+        },
+        ...email && {
+            email: parseEmail(email)
+        },
+        ...normalizedFirst && {
+            firstName: parseVarChar(normalizedFirst, 160)
+        },
+        ...gender && {
+            gender: validateGender(gender)
+        },
+        ...imageId && {
+            imageId: parseReaktorItemId(imageId)
+        },
+        ...normalizedLast && {
+            lastName: parseVarChar(normalizedLast, 160)
+        },
+        ...lastActive !== undefined && {
+            lastActive: parseReaktorDate(lastActive)
+        },
+        ...locale && {
+            locale: parseString(locale, 5)
+        },
+        ...mailingList !== undefined && {
+            mailingList: !!mailingList
+        },
+        ...name && {
+            name: parseReaktorName(name)
+        },
+        ...password && {
+            password: parseVarChar(password, 160)
+        },
+        ...phone && {
+            phone: validatePhone(phone)
+        },
+        ...planExpires !== undefined && {
+            planExpires: parseReaktorDate(planExpires)
+        },
+        ...planId && {
+            planId: parseVarChar(planId, 160)
+        },
+        ...planStatus && {
+            planStatus: parseVarChar(planStatus, 160)
+        },
+        ...planSubscriptionId && {
+            planSubscriptionId: parseVarChar(planSubscriptionId, 160)
+        },
+        ...salt && {
+            salt: parseVarChar(salt, 160)
+        },
+        ...state && {
+            state: validateState(state)
+        },
+        ...street1 && {
+            street1: parseVarChar(street1, 160)
+        },
+        ...street2 && {
+            street2: parseVarChar(street2, 160)
+        },
+        ...stripeAccountId && {
+            stripeAccountId: parseVarChar(stripeAccountId, 160)
+        },
+        ...stripeCardBrand && {
+            stripeCardBrand: parseVarChar(stripeCardBrand, 160)
+        },
+        ...stripeCardId && {
+            stripeCardId: parseVarChar(stripeCardId, 160)
+        },
+        ...stripeCardLast4 && {
+            stripeCardLast4: parseVarChar(stripeCardLast4, 4)
+        },
+        ...stripeCustomerId && {
+            stripeCustomerId: parseVarChar(stripeCustomerId, 160)
+        },
+        ...timezone && {
+            timezone: parseString(timezone, 160)
+        },
+        ...type && {
+            type: parseReaktorType(type)
+        },
+        ...userAccess !== undefined && {
+            userAccess: userAccess ? parseNum(userAccess) : 0
+        },
+        ...username && {
+            username: parseVarChar(username, 160)
+        },
+        ...verifiedEmail !== undefined && {
+            verifiedEmail: !!verifiedEmail
+        },
+        ...verifiedEmailCode !== undefined && {
+            verifiedEmailCode: parseNum(verifiedEmailCode, 10)
+        },
+        ...verifiedEmailExpires !== undefined && {
+            verifiedEmailExpires: parseNum(verifiedEmailExpires, 10)
+        },
+        ...verifiedPhone !== undefined && {
+            verifiedPhone: !!verifiedPhone
+        },
+        ...verifiedPhoneExpires !== undefined && {
+            verifiedPhoneExpires: parseNum(verifiedPhoneExpires, 10)
+        },
+        ...verifiedSmsCode !== undefined && {
+            verifiedSmsCode: parseNum(verifiedSmsCode, 10)
+        },
+        ...zip && {
+            zip: parseVarChar(zip, 20)
+        }
+    };
+    const result = removeEmptyKeys(transformed);
+    if (user._id) {
+        result.id = user._id;
+        result._id = user._id;
+    } else if (user.id && !result.id) {
+        result.id = user.id;
+        result._id = user.id;
+    }
+    if (user._key) {
+        result.userId = user._key;
+        result._key = user._key;
+    } else if (user.userId && !result.userId) {
+        result.userId = user.userId;
+        result._key = user.userId;
+    }
+    if (user.userId && !result._key) {
+        result._key = user.userId;
+    }
+    if (user.id && !result._id) {
+        result._id = user.id;
+    }
+    return result;
+};
+export const clearUserCache = ()=>{
+    userCache.clear();
+};
+export const getUserCacheSize = ()=>userCache.size;
+export { userCache };
+export const parseUserLegacy = (user)=>parseUser(user);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/adapters/userAdapter/userAdapter.ts"],"sourcesContent":["import {parseArangoId, parseChar, parseEmail, parseId, parseNum, parseString, parseVarChar} from '@nlabs/utils';\nimport {z} from 'zod';\n\nimport {parseDocument, removeEmptyKeys} from '../arangoAdapter/arangoAdapter.js';\nimport {parseReaktorDate, parseReaktorItemId, parseReaktorName, parseReaktorType} from '../reaktorAdapter/reaktorAdapter.js';\n\nexport interface User {\n  [key: string]: any;\n  _id?: string;\n  _key?: string;\n  active?: boolean;\n  added?: number;\n  bankId?: string;\n  city?: string;\n  country?: string;\n  currency?: string;\n  deviceToken?: string;\n  dob?: number;\n  birthdate?: number;\n  email?: string;\n  firstName?: string;\n  gender?: string;\n  id?: string;\n  imageId?: string;\n  lastName?: string;\n  lastActive?: number;\n  locale?: string;\n  mailingList?: boolean;\n  modified?: number;\n  name?: string;\n  password?: string;\n  phone?: string;\n  planExpires?: number;\n  planId?: string;\n  planStatus?: string;\n  planSubscriptionId?: string;\n  salt?: string;\n  state?: string;\n  street1?: string;\n  street2?: string;\n  stripeAccountId?: string;\n  stripeCardBrand?: string;\n  stripeCardId?: string;\n  stripeCardLast4?: string;\n  stripeCustomerId?: string;\n  timezone?: string;\n  thumbUrl?: string;\n  type?: string;\n  updated?: number;\n  userAccess?: number;\n  userId?: string;\n  username?: string;\n  verifiedEmail?: boolean;\n  verifiedEmailCode?: number;\n  verifiedEmailExpires?: number;\n  verifiedPhone?: boolean;\n  verifiedPhoneExpires?: number;\n  verifiedSmsCode?: number;\n  zip?: string;\n}\n\nexport class UserValidationError extends Error {\n  constructor(message: string, public field?: string) {\n    super(message);\n    this.name = 'UserValidationError';\n  }\n}\n\nconst UserInputSchema = z.object({\n  _id: z.string().optional(),\n  _key: z.string().optional(),\n  active: z.boolean().optional(),\n  added: z.number().optional(),\n  bankId: z.string().max(160).optional(),\n  city: z.string().max(160).optional(),\n  country: z.string().length(2).optional(),\n  currency: z.string().length(3).optional(),\n  deviceToken: z.string().max(160).optional(),\n  dob: z.number().optional(),\n  birthdate: z.number().optional(),\n  email: z.email().optional(),\n  firstName: z.string().max(160).optional(),\n  gender: z.string().length(1).optional(),\n  id: z.string().optional(),\n  imageId: z.string().optional(),\n  lastName: z.string().max(160).optional(),\n  lastActive: z.number().optional(),\n  locale: z.string().max(5).optional(),\n  mailingList: z.boolean().optional(),\n  name: z.string().max(160).optional(),\n  password: z.string().max(160).optional(),\n  phone: z.string().max(20).optional(),\n  planExpires: z.number().optional(),\n  planId: z.string().max(160).optional(),\n  planStatus: z.string().max(160).optional(),\n  planSubscriptionId: z.string().max(160).optional(),\n  salt: z.string().max(160).optional(),\n  state: z.string().length(2).optional(),\n  street1: z.string().max(160).optional(),\n  street2: z.string().max(160).optional(),\n  stripeAccountId: z.string().max(160).optional(),\n  stripeCardBrand: z.string().max(160).optional(),\n  stripeCardId: z.string().max(160).optional(),\n  stripeCardLast4: z.string().max(4).optional(),\n  stripeCustomerId: z.string().max(160).optional(),\n  timezone: z.string().max(160).optional(),\n  type: z.string().max(160).optional(),\n  updated: z.number().optional(),\n  userAccess: z.number().optional(),\n  userId: z.string().optional(),\n  username: z.string().max(160).optional(),\n  verifiedEmail: z.boolean().optional(),\n  verifiedEmailCode: z.number().optional(),\n  verifiedEmailExpires: z.number().optional(),\n  verifiedPhone: z.boolean().optional(),\n  verifiedPhoneExpires: z.number().optional(),\n  verifiedSmsCode: z.number().optional(),\n  zip: z.string().max(20).optional()\n}).loose();\n\nconst validatePhone = (phone?: string): string | undefined => {\n  if(!phone) {\n    return undefined;\n  }\n  const cleaned = phone.replace(/\\D/g, '');\n  if(cleaned.length < 10 || cleaned.length > 15) {\n    throw new UserValidationError('Invalid phone number format', 'phone');\n  }\n  return `+${cleaned}`;\n};\n\nconst validateCountry = (country?: string): string | undefined => {\n  if(!country) {\n    return undefined;\n  }\n  const upper = country.toUpperCase();\n  if(!/^[A-Z]{2}$/.test(upper)) {\n    throw new UserValidationError('Country must be a 2-letter ISO code', 'country');\n  }\n  return upper;\n};\n\nconst validateState = (state?: string): string | undefined => {\n  if(!state) {\n    return undefined;\n  }\n  const upper = state.toUpperCase();\n  if(!/^[A-Z]{2}$/.test(upper)) {\n    throw new UserValidationError('State must be a 2-letter code', 'state');\n  }\n  return upper;\n};\n\nconst validateGender = (gender?: string): string | undefined => {\n  if(!gender) {\n    return undefined;\n  }\n  const upper = gender.toUpperCase();\n  if(!/^[MF]$/.test(upper)) {\n    throw new UserValidationError('Gender must be M or F', 'gender');\n  }\n  return upper;\n};\n\nconst userCache = new Map<string, User>();\n\nexport const validateUserInput = (user: unknown): User => {\n  try {\n    const validated = UserInputSchema.parse(user);\n    return validated as User;\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 UserValidationError(`User validation failed: ${fieldErrors}`);\n    }\n    throw error;\n  }\n};\n\nexport const formatUserOutput = (user: User): User => {\n  const {password, salt, verifiedEmailCode, verifiedSmsCode, ...safeUser} = user;\n  return safeUser;\n};\n\nexport const parseUser = (user: User): User => {\n  try {\n    const parsed = performUserTransformation(user);\n    return parsed;\n  } catch(error) {\n    if(error instanceof UserValidationError) {\n      throw error;\n    }\n    throw new UserValidationError(`User parsing failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n  }\n};\n\nconst performUserTransformation = (user: User): User => {\n  const {\n    _id,\n    _key,\n    active,\n    bankId,\n    city,\n    country,\n    currency,\n    deviceToken,\n    dob,\n    birthdate,\n    email,\n    firstName,\n    gender,\n    id,\n    imageId,\n    lastName,\n    lastActive,\n    locale,\n    mailingList,\n    name,\n    password,\n    phone,\n    planExpires,\n    planId,\n    planStatus,\n    planSubscriptionId,\n    salt,\n    state,\n    street1,\n    street2,\n    stripeAccountId,\n    stripeCardBrand,\n    stripeCardId,\n    stripeCardLast4,\n    stripeCustomerId,\n    timezone,\n    type,\n    userAccess,\n    userId,\n    username,\n    verifiedEmail,\n    verifiedEmailCode,\n    verifiedEmailExpires,\n    verifiedPhone,\n    verifiedPhoneExpires,\n    verifiedSmsCode,\n    zip\n  } = user;\n  const normalizedDob = birthdate ?? dob;\n  const normalizedFirst = firstName;\n  const normalizedLast = lastName;\n  const transformed = {\n    ...parseDocument(user),\n    ...((_id || id || _key || userId) && {id: parseArangoId(_id || id || `users/${_key || userId}`)}),\n    ...((_key || userId) && {userId: parseId(_key || userId || '')}),\n    ...(active !== undefined && {active: !!active}),\n    ...(bankId && {bankId: parseVarChar(bankId, 160)}),\n    ...(city && {city: parseVarChar(city, 160)}),\n    ...(country && {country: validateCountry(country)}),\n    ...(currency && {currency: parseChar(currency, 3).toUpperCase()}),\n    ...(deviceToken && {deviceToken: parseVarChar(deviceToken, 160)}),\n    ...(normalizedDob !== undefined && {birthdate: parseReaktorDate(normalizedDob), dob: parseReaktorDate(normalizedDob)}),\n    ...(email && {email: parseEmail(email)}),\n    ...(normalizedFirst && {firstName: parseVarChar(normalizedFirst, 160)}),\n    ...(gender && {gender: validateGender(gender)}),\n    ...(imageId && {imageId: parseReaktorItemId(imageId)}),\n    ...(normalizedLast && {lastName: parseVarChar(normalizedLast, 160)}),\n    ...(lastActive !== undefined && {lastActive: parseReaktorDate(lastActive)}),\n    ...(locale && {locale: parseString(locale, 5)}),\n    ...(mailingList !== undefined && {mailingList: !!mailingList}),\n    ...(name && {name: parseReaktorName(name)}),\n    ...(password && {password: parseVarChar(password, 160)}),\n    ...(phone && {phone: validatePhone(phone)}),\n    ...(planExpires !== undefined && {planExpires: parseReaktorDate(planExpires)}),\n    ...(planId && {planId: parseVarChar(planId, 160)}),\n    ...(planStatus && {planStatus: parseVarChar(planStatus, 160)}),\n    ...(planSubscriptionId && {planSubscriptionId: parseVarChar(planSubscriptionId, 160)}),\n    ...(salt && {salt: parseVarChar(salt, 160)}),\n    ...(state && {state: validateState(state)}),\n    ...(street1 && {street1: parseVarChar(street1, 160)}),\n    ...(street2 && {street2: parseVarChar(street2, 160)}),\n    ...(stripeAccountId && {stripeAccountId: parseVarChar(stripeAccountId, 160)}),\n    ...(stripeCardBrand && {stripeCardBrand: parseVarChar(stripeCardBrand, 160)}),\n    ...(stripeCardId && {stripeCardId: parseVarChar(stripeCardId, 160)}),\n    ...(stripeCardLast4 && {stripeCardLast4: parseVarChar(stripeCardLast4, 4)}),\n    ...(stripeCustomerId && {stripeCustomerId: parseVarChar(stripeCustomerId, 160)}),\n    ...(timezone && {timezone: parseString(timezone, 160)}),\n    ...(type && {type: parseReaktorType(type)}),\n    ...(userAccess !== undefined && {userAccess: userAccess ? parseNum(userAccess) : 0}),\n    ...(username && {username: parseVarChar(username, 160)}),\n    ...(verifiedEmail !== undefined && {verifiedEmail: !!verifiedEmail}),\n    ...(verifiedEmailCode !== undefined && {verifiedEmailCode: parseNum(verifiedEmailCode, 10)}),\n    ...(verifiedEmailExpires !== undefined && {verifiedEmailExpires: parseNum(verifiedEmailExpires, 10)}),\n    ...(verifiedPhone !== undefined && {verifiedPhone: !!verifiedPhone}),\n    ...(verifiedPhoneExpires !== undefined && {verifiedPhoneExpires: parseNum(verifiedPhoneExpires, 10)}),\n    ...(verifiedSmsCode !== undefined && {verifiedSmsCode: parseNum(verifiedSmsCode, 10)}),\n    ...(zip && {zip: parseVarChar(zip, 20)})\n  };\n\n  const result = removeEmptyKeys(transformed);\n\n  if(user._id) {\n    result.id = user._id;\n    result._id = user._id;\n  } else if(user.id && !result.id) {\n    result.id = user.id;\n    result._id = user.id;\n  }\n\n  if(user._key) {\n    result.userId = user._key;\n    result._key = user._key;\n  } else if(user.userId && !result.userId) {\n    result.userId = user.userId;\n    result._key = user.userId;\n  }\n\n  if(user.userId && !result._key) {\n    result._key = user.userId;\n  }\n\n  if(user.id && !result._id) {\n    result._id = user.id;\n  }\n\n  return result;\n};\n\nexport const clearUserCache = (): void => {\n  userCache.clear();\n};\n\nexport const getUserCacheSize = (): number => userCache.size;\n\nexport {userCache};\n\nexport const parseUserLegacy = (user: User): User => parseUser(user);\n"],"names":["parseArangoId","parseChar","parseEmail","parseId","parseNum","parseString","parseVarChar","z","parseDocument","removeEmptyKeys","parseReaktorDate","parseReaktorItemId","parseReaktorName","parseReaktorType","UserValidationError","Error","message","field","name","UserInputSchema","object","_id","string","optional","_key","active","boolean","added","number","bankId","max","city","country","length","currency","deviceToken","dob","birthdate","email","firstName","gender","id","imageId","lastName","lastActive","locale","mailingList","password","phone","planExpires","planId","planStatus","planSubscriptionId","salt","state","street1","street2","stripeAccountId","stripeCardBrand","stripeCardId","stripeCardLast4","stripeCustomerId","timezone","type","updated","userAccess","userId","username","verifiedEmail","verifiedEmailCode","verifiedEmailExpires","verifiedPhone","verifiedPhoneExpires","verifiedSmsCode","zip","loose","validatePhone","undefined","cleaned","replace","validateCountry","upper","toUpperCase","test","validateState","validateGender","userCache","Map","validateUserInput","user","validated","parse","error","ZodError","fieldErrors","issues","map","e","path","join","formatUserOutput","safeUser","parseUser","parsed","performUserTransformation","normalizedDob","normalizedFirst","normalizedLast","transformed","result","clearUserCache","clear","getUserCacheSize","size","parseUserLegacy"],"mappings":"AAAA,SAAQA,aAAa,EAAEC,SAAS,EAAEC,UAAU,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,WAAW,EAAEC,YAAY,QAAO,eAAe;AAChH,SAAQC,CAAC,QAAO,MAAM;AAEtB,SAAQC,aAAa,EAAEC,eAAe,QAAO,oCAAoC;AACjF,SAAQC,gBAAgB,EAAEC,kBAAkB,EAAEC,gBAAgB,EAAEC,gBAAgB,QAAO,sCAAsC;AAyD7H,OAAO,MAAMC,4BAA4BC;;IACvC,YAAYC,OAAe,EAAE,AAAOC,KAAc,CAAE;QAClD,KAAK,CAACD,eAD4BC,QAAAA;QAElC,IAAI,CAACC,IAAI,GAAG;IACd;AACF;AAEA,MAAMC,kBAAkBZ,EAAEa,MAAM,CAAC;IAC/BC,KAAKd,EAAEe,MAAM,GAAGC,QAAQ;IACxBC,MAAMjB,EAAEe,MAAM,GAAGC,QAAQ;IACzBE,QAAQlB,EAAEmB,OAAO,GAAGH,QAAQ;IAC5BI,OAAOpB,EAAEqB,MAAM,GAAGL,QAAQ;IAC1BM,QAAQtB,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACpCQ,MAAMxB,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAClCS,SAASzB,EAAEe,MAAM,GAAGW,MAAM,CAAC,GAAGV,QAAQ;IACtCW,UAAU3B,EAAEe,MAAM,GAAGW,MAAM,CAAC,GAAGV,QAAQ;IACvCY,aAAa5B,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACzCa,KAAK7B,EAAEqB,MAAM,GAAGL,QAAQ;IACxBc,WAAW9B,EAAEqB,MAAM,GAAGL,QAAQ;IAC9Be,OAAO/B,EAAE+B,KAAK,GAAGf,QAAQ;IACzBgB,WAAWhC,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACvCiB,QAAQjC,EAAEe,MAAM,GAAGW,MAAM,CAAC,GAAGV,QAAQ;IACrCkB,IAAIlC,EAAEe,MAAM,GAAGC,QAAQ;IACvBmB,SAASnC,EAAEe,MAAM,GAAGC,QAAQ;IAC5BoB,UAAUpC,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACtCqB,YAAYrC,EAAEqB,MAAM,GAAGL,QAAQ;IAC/BsB,QAAQtC,EAAEe,MAAM,GAAGQ,GAAG,CAAC,GAAGP,QAAQ;IAClCuB,aAAavC,EAAEmB,OAAO,GAAGH,QAAQ;IACjCL,MAAMX,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAClCwB,UAAUxC,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACtCyB,OAAOzC,EAAEe,MAAM,GAAGQ,GAAG,CAAC,IAAIP,QAAQ;IAClC0B,aAAa1C,EAAEqB,MAAM,GAAGL,QAAQ;IAChC2B,QAAQ3C,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACpC4B,YAAY5C,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACxC6B,oBAAoB7C,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAChD8B,MAAM9C,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAClC+B,OAAO/C,EAAEe,MAAM,GAAGW,MAAM,CAAC,GAAGV,QAAQ;IACpCgC,SAAShD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACrCiC,SAASjD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACrCkC,iBAAiBlD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAC7CmC,iBAAiBnD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAC7CoC,cAAcpD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAC1CqC,iBAAiBrD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,GAAGP,QAAQ;IAC3CsC,kBAAkBtD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAC9CuC,UAAUvD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACtCwC,MAAMxD,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IAClCyC,SAASzD,EAAEqB,MAAM,GAAGL,QAAQ;IAC5B0C,YAAY1D,EAAEqB,MAAM,GAAGL,QAAQ;IAC/B2C,QAAQ3D,EAAEe,MAAM,GAAGC,QAAQ;IAC3B4C,UAAU5D,EAAEe,MAAM,GAAGQ,GAAG,CAAC,KAAKP,QAAQ;IACtC6C,eAAe7D,EAAEmB,OAAO,GAAGH,QAAQ;IACnC8C,mBAAmB9D,EAAEqB,MAAM,GAAGL,QAAQ;IACtC+C,sBAAsB/D,EAAEqB,MAAM,GAAGL,QAAQ;IACzCgD,eAAehE,EAAEmB,OAAO,GAAGH,QAAQ;IACnCiD,sBAAsBjE,EAAEqB,MAAM,GAAGL,QAAQ;IACzCkD,iBAAiBlE,EAAEqB,MAAM,GAAGL,QAAQ;IACpCmD,KAAKnE,EAAEe,MAAM,GAAGQ,GAAG,CAAC,IAAIP,QAAQ;AAClC,GAAGoD,KAAK;AAER,MAAMC,gBAAgB,CAAC5B;IACrB,IAAG,CAACA,OAAO;QACT,OAAO6B;IACT;IACA,MAAMC,UAAU9B,MAAM+B,OAAO,CAAC,OAAO;IACrC,IAAGD,QAAQ7C,MAAM,GAAG,MAAM6C,QAAQ7C,MAAM,GAAG,IAAI;QAC7C,MAAM,IAAInB,oBAAoB,+BAA+B;IAC/D;IACA,OAAO,CAAC,CAAC,EAAEgE,SAAS;AACtB;AAEA,MAAME,kBAAkB,CAAChD;IACvB,IAAG,CAACA,SAAS;QACX,OAAO6C;IACT;IACA,MAAMI,QAAQjD,QAAQkD,WAAW;IACjC,IAAG,CAAC,aAAaC,IAAI,CAACF,QAAQ;QAC5B,MAAM,IAAInE,oBAAoB,uCAAuC;IACvE;IACA,OAAOmE;AACT;AAEA,MAAMG,gBAAgB,CAAC9B;IACrB,IAAG,CAACA,OAAO;QACT,OAAOuB;IACT;IACA,MAAMI,QAAQ3B,MAAM4B,WAAW;IAC/B,IAAG,CAAC,aAAaC,IAAI,CAACF,QAAQ;QAC5B,MAAM,IAAInE,oBAAoB,iCAAiC;IACjE;IACA,OAAOmE;AACT;AAEA,MAAMI,iBAAiB,CAAC7C;IACtB,IAAG,CAACA,QAAQ;QACV,OAAOqC;IACT;IACA,MAAMI,QAAQzC,OAAO0C,WAAW;IAChC,IAAG,CAAC,SAASC,IAAI,CAACF,QAAQ;QACxB,MAAM,IAAInE,oBAAoB,yBAAyB;IACzD;IACA,OAAOmE;AACT;AAEA,MAAMK,YAAY,IAAIC;AAEtB,OAAO,MAAMC,oBAAoB,CAACC;IAChC,IAAI;QACF,MAAMC,YAAYvE,gBAAgBwE,KAAK,CAACF;QACxC,OAAOC;IACT,EAAE,OAAME,OAAO;QACb,IAAGA,iBAAiBrF,EAAEsF,QAAQ,EAAE;YAC9B,MAAMC,cAAcF,MAAMG,MAAM,CAACC,GAAG,CAAC,CAACC,IAAM,GAAGA,EAAEC,IAAI,CAACC,IAAI,CAAC,KAAK,EAAE,EAAEF,EAAEjF,OAAO,EAAE,EAAEmF,IAAI,CAAC;YACtF,MAAM,IAAIrF,oBAAoB,CAAC,wBAAwB,EAAEgF,aAAa;QACxE;QACA,MAAMF;IACR;AACF,EAAE;AAEF,OAAO,MAAMQ,mBAAmB,CAACX;IAC/B,MAAM,EAAC1C,QAAQ,EAAEM,IAAI,EAAEgB,iBAAiB,EAAEI,eAAe,EAAE,GAAG4B,UAAS,GAAGZ;IAC1E,OAAOY;AACT,EAAE;AAEF,OAAO,MAAMC,YAAY,CAACb;IACxB,IAAI;QACF,MAAMc,SAASC,0BAA0Bf;QACzC,OAAOc;IACT,EAAE,OAAMX,OAAO;QACb,IAAGA,iBAAiB9E,qBAAqB;YACvC,MAAM8E;QACR;QACA,MAAM,IAAI9E,oBAAoB,CAAC,qBAAqB,EAAE8E,iBAAiB7E,QAAQ6E,MAAM5E,OAAO,GAAG,iBAAiB;IAClH;AACF,EAAE;AAEF,MAAMwF,4BAA4B,CAACf;IACjC,MAAM,EACJpE,GAAG,EACHG,IAAI,EACJC,MAAM,EACNI,MAAM,EACNE,IAAI,EACJC,OAAO,EACPE,QAAQ,EACRC,WAAW,EACXC,GAAG,EACHC,SAAS,EACTC,KAAK,EACLC,SAAS,EACTC,MAAM,EACNC,EAAE,EACFC,OAAO,EACPC,QAAQ,EACRC,UAAU,EACVC,MAAM,EACNC,WAAW,EACX5B,IAAI,EACJ6B,QAAQ,EACRC,KAAK,EACLC,WAAW,EACXC,MAAM,EACNC,UAAU,EACVC,kBAAkB,EAClBC,IAAI,EACJC,KAAK,EACLC,OAAO,EACPC,OAAO,EACPC,eAAe,EACfC,eAAe,EACfC,YAAY,EACZC,eAAe,EACfC,gBAAgB,EAChBC,QAAQ,EACRC,IAAI,EACJE,UAAU,EACVC,MAAM,EACNC,QAAQ,EACRC,aAAa,EACbC,iBAAiB,EACjBC,oBAAoB,EACpBC,aAAa,EACbC,oBAAoB,EACpBC,eAAe,EACfC,GAAG,EACJ,GAAGe;IACJ,MAAMgB,gBAAgBpE,aAAaD;IACnC,MAAMsE,kBAAkBnE;IACxB,MAAMoE,iBAAiBhE;IACvB,MAAMiE,cAAc;QAClB,GAAGpG,cAAciF,KAAK;QACtB,GAAI,AAACpE,CAAAA,OAAOoB,MAAMjB,QAAQ0C,MAAK,KAAM;YAACzB,IAAIzC,cAAcqB,OAAOoB,MAAM,CAAC,MAAM,EAAEjB,QAAQ0C,QAAQ;QAAC,CAAC;QAChG,GAAI,AAAC1C,CAAAA,QAAQ0C,MAAK,KAAM;YAACA,QAAQ/D,QAAQqB,QAAQ0C,UAAU;QAAG,CAAC;QAC/D,GAAIzC,WAAWoD,aAAa;YAACpD,QAAQ,CAAC,CAACA;QAAM,CAAC;QAC9C,GAAII,UAAU;YAACA,QAAQvB,aAAauB,QAAQ;QAAI,CAAC;QACjD,GAAIE,QAAQ;YAACA,MAAMzB,aAAayB,MAAM;QAAI,CAAC;QAC3C,GAAIC,WAAW;YAACA,SAASgD,gBAAgBhD;QAAQ,CAAC;QAClD,GAAIE,YAAY;YAACA,UAAUjC,UAAUiC,UAAU,GAAGgD,WAAW;QAAE,CAAC;QAChE,GAAI/C,eAAe;YAACA,aAAa7B,aAAa6B,aAAa;QAAI,CAAC;QAChE,GAAIsE,kBAAkB5B,aAAa;YAACxC,WAAW3B,iBAAiB+F;YAAgBrE,KAAK1B,iBAAiB+F;QAAc,CAAC;QACrH,GAAInE,SAAS;YAACA,OAAOpC,WAAWoC;QAAM,CAAC;QACvC,GAAIoE,mBAAmB;YAACnE,WAAWjC,aAAaoG,iBAAiB;QAAI,CAAC;QACtE,GAAIlE,UAAU;YAACA,QAAQ6C,eAAe7C;QAAO,CAAC;QAC9C,GAAIE,WAAW;YAACA,SAAS/B,mBAAmB+B;QAAQ,CAAC;QACrD,GAAIiE,kBAAkB;YAAChE,UAAUrC,aAAaqG,gBAAgB;QAAI,CAAC;QACnE,GAAI/D,eAAeiC,aAAa;YAACjC,YAAYlC,iBAAiBkC;QAAW,CAAC;QAC1E,GAAIC,UAAU;YAACA,QAAQxC,YAAYwC,QAAQ;QAAE,CAAC;QAC9C,GAAIC,gBAAgB+B,aAAa;YAAC/B,aAAa,CAAC,CAACA;QAAW,CAAC;QAC7D,GAAI5B,QAAQ;YAACA,MAAMN,iBAAiBM;QAAK,CAAC;QAC1C,GAAI6B,YAAY;YAACA,UAAUzC,aAAayC,UAAU;QAAI,CAAC;QACvD,GAAIC,SAAS;YAACA,OAAO4B,cAAc5B;QAAM,CAAC;QAC1C,GAAIC,gBAAgB4B,aAAa;YAAC5B,aAAavC,iBAAiBuC;QAAY,CAAC;QAC7E,GAAIC,UAAU;YAACA,QAAQ5C,aAAa4C,QAAQ;QAAI,CAAC;QACjD,GAAIC,cAAc;YAACA,YAAY7C,aAAa6C,YAAY;QAAI,CAAC;QAC7D,GAAIC,sBAAsB;YAACA,oBAAoB9C,aAAa8C,oBAAoB;QAAI,CAAC;QACrF,GAAIC,QAAQ;YAACA,MAAM/C,aAAa+C,MAAM;QAAI,CAAC;QAC3C,GAAIC,SAAS;YAACA,OAAO8B,cAAc9B;QAAM,CAAC;QAC1C,GAAIC,WAAW;YAACA,SAASjD,aAAaiD,SAAS;QAAI,CAAC;QACpD,GAAIC,WAAW;YAACA,SAASlD,aAAakD,SAAS;QAAI,CAAC;QACpD,GAAIC,mBAAmB;YAACA,iBAAiBnD,aAAamD,iBAAiB;QAAI,CAAC;QAC5E,GAAIC,mBAAmB;YAACA,iBAAiBpD,aAAaoD,iBAAiB;QAAI,CAAC;QAC5E,GAAIC,gBAAgB;YAACA,cAAcrD,aAAaqD,cAAc;QAAI,CAAC;QACnE,GAAIC,mBAAmB;YAACA,iBAAiBtD,aAAasD,iBAAiB;QAAE,CAAC;QAC1E,GAAIC,oBAAoB;YAACA,kBAAkBvD,aAAauD,kBAAkB;QAAI,CAAC;QAC/E,GAAIC,YAAY;YAACA,UAAUzD,YAAYyD,UAAU;QAAI,CAAC;QACtD,GAAIC,QAAQ;YAACA,MAAMlD,iBAAiBkD;QAAK,CAAC;QAC1C,GAAIE,eAAeY,aAAa;YAACZ,YAAYA,aAAa7D,SAAS6D,cAAc;QAAC,CAAC;QACnF,GAAIE,YAAY;YAACA,UAAU7D,aAAa6D,UAAU;QAAI,CAAC;QACvD,GAAIC,kBAAkBS,aAAa;YAACT,eAAe,CAAC,CAACA;QAAa,CAAC;QACnE,GAAIC,sBAAsBQ,aAAa;YAACR,mBAAmBjE,SAASiE,mBAAmB;QAAG,CAAC;QAC3F,GAAIC,yBAAyBO,aAAa;YAACP,sBAAsBlE,SAASkE,sBAAsB;QAAG,CAAC;QACpG,GAAIC,kBAAkBM,aAAa;YAACN,eAAe,CAAC,CAACA;QAAa,CAAC;QACnE,GAAIC,yBAAyBK,aAAa;YAACL,sBAAsBpE,SAASoE,sBAAsB;QAAG,CAAC;QACpG,GAAIC,oBAAoBI,aAAa;YAACJ,iBAAiBrE,SAASqE,iBAAiB;QAAG,CAAC;QACrF,GAAIC,OAAO;YAACA,KAAKpE,aAAaoE,KAAK;QAAG,CAAC;IACzC;IAEA,MAAMmC,SAASpG,gBAAgBmG;IAE/B,IAAGnB,KAAKpE,GAAG,EAAE;QACXwF,OAAOpE,EAAE,GAAGgD,KAAKpE,GAAG;QACpBwF,OAAOxF,GAAG,GAAGoE,KAAKpE,GAAG;IACvB,OAAO,IAAGoE,KAAKhD,EAAE,IAAI,CAACoE,OAAOpE,EAAE,EAAE;QAC/BoE,OAAOpE,EAAE,GAAGgD,KAAKhD,EAAE;QACnBoE,OAAOxF,GAAG,GAAGoE,KAAKhD,EAAE;IACtB;IAEA,IAAGgD,KAAKjE,IAAI,EAAE;QACZqF,OAAO3C,MAAM,GAAGuB,KAAKjE,IAAI;QACzBqF,OAAOrF,IAAI,GAAGiE,KAAKjE,IAAI;IACzB,OAAO,IAAGiE,KAAKvB,MAAM,IAAI,CAAC2C,OAAO3C,MAAM,EAAE;QACvC2C,OAAO3C,MAAM,GAAGuB,KAAKvB,MAAM;QAC3B2C,OAAOrF,IAAI,GAAGiE,KAAKvB,MAAM;IAC3B;IAEA,IAAGuB,KAAKvB,MAAM,IAAI,CAAC2C,OAAOrF,IAAI,EAAE;QAC9BqF,OAAOrF,IAAI,GAAGiE,KAAKvB,MAAM;IAC3B;IAEA,IAAGuB,KAAKhD,EAAE,IAAI,CAACoE,OAAOxF,GAAG,EAAE;QACzBwF,OAAOxF,GAAG,GAAGoE,KAAKhD,EAAE;IACtB;IAEA,OAAOoE;AACT;AAEA,OAAO,MAAMC,iBAAiB;IAC5BxB,UAAUyB,KAAK;AACjB,EAAE;AAEF,OAAO,MAAMC,mBAAmB,IAAc1B,UAAU2B,IAAI,CAAC;AAE7D,SAAQ3B,SAAS,GAAE;AAEnB,OAAO,MAAM4B,kBAAkB,CAACzB,OAAqBa,UAAUb,MAAM"}

package/lib/adapters/videoAdapter/videoAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { VideoType } from '../../types/videos.types.js';
+export declare class VideoValidationError extends Error {
+    field?: string;
+    constructor(message: string, field?: string);
+}
+export declare const validateVideoInput: (video: unknown) => VideoType;
+export declare const parseVideo: (video: VideoType) => VideoType;
+//# sourceMappingURL=videoAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"videoAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/videoAdapter/videoAdapter.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,6BAA6B,CAAC;AAE3D,qBAAa,oBAAqB,SAAQ,KAAK;IACT,KAAK,CAAC,EAAE,MAAM;gBAAtC,OAAO,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,MAAM;CAInD;AA2CD,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,SAWnD,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,OAAO,SAAS,KAAG,SAU7C,CAAC"}

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

@@ -0,0 +1,44 @@
+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;
+}
+export interface ConfigAppApiType {
+    readonly public?: string;
+    readonly url?: string;
+    readonly uploadImage?: string;
+}
+export interface ConfigAppType {
+    readonly api?: ConfigAppApiType;
+    readonly name?: string;
+    readonly session?: ConfigAppSessionType;
+    readonly urls?: ConfigAppUrls;
+    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;
+}
+/**
+ * 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"}