@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/tags.js

@@ -0,0 +1,263 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { createHash, parseArangoId, parseId, parseVarChar } from '@nlabs/utils/parsers/strings';
+import { words } from '@nlabs/utils/strings/words';
+import { aql } from 'arangojs';
+import { parseTag } from '../adapters/tagAdapter.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { getDocId, getLimit, useDb } from '../utils/arangodbUtils.js';
+const eventCategory = 'tags';
+export const getTags = (context, options = {})=>{
+    const action = 'getList';
+    const { databaseName } = context;
+    const { search = '', from = 0, to = 30, userId } = options;
+    const limit = getLimit(from, to);
+    const filters = [];
+    if (search) {
+        filters.push(`LIKE(t.name, "%${search}%")`);
+    }
+    if (userId) {
+        filters.push(`t.userId == "${userId}"`);
+    }
+    const aqlQry = `FOR t IN tags
+    FILTER ${filters.join(' || ')}
+    ${limit.aql}
+    SORT t.name
+    RETURN t`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+        return [];
+    });
+};
+export const getTagsByItem = (context, itemDocId, options = {})=>{
+    const action = 'getTagsByItem';
+    const { from = 0, to = 30 } = options;
+    const { databaseName } = context;
+    const limit = getLimit(from, to);
+    const formatItemId = parseArangoId(itemDocId);
+    const tagQuery = `FOR t, it IN INBOUND "${formatItemId}" isTagged
+    ${limit.aql}
+    SORT it.added
+    RETURN t`;
+    return useDb(databaseName).query(tagQuery).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+        return [];
+    });
+};
+export const getTag = (context, tagId)=>{
+    const action = 'getTag';
+    const { databaseName } = context;
+    const formatId = parseId(tagId);
+    const aqlQry = `FOR t IN tags
+    FILTER t._key == "${formatId}"
+    LIMIT 1
+    RETURN t`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+};
+export const getTagsByName = (context, tagNames)=>{
+    const action = 'getTagsByName';
+    const { databaseName } = context;
+    const formatTagNames = tagNames.map((tagName)=>parseVarChar(tagName, 32)).filter((tagName)=>!!tagName);
+    if (!formatTagNames.length) {
+        return Promise.resolve([]);
+    }
+    const aqlQry = aql`FOR t IN tags
+    FILTER POSITION(${JSON.stringify(formatTagNames)}, t.name)
+    RETURN t`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+        return [];
+    });
+};
+export const addTag = (context, tag)=>{
+    const action = 'addTag';
+    const { databaseName } = context;
+    const now = Date.now();
+    const { description, name } = parseTag(tag);
+    const formatId = createHash(`tag-${name?.toLowerCase()}`);
+    const insert = {
+        _key: formatId,
+        added: now,
+        description: parseVarChar(description, 64),
+        modified: now,
+        name: parseVarChar(name, 32)
+    };
+    const aqlQry = aql`INSERT ${insert} IN tags RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+};
+export const addTagToItem = async (context, { itemDocId, tagBy = '', tagDocId })=>{
+    const action = 'addTagToItem';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const added = Date.now();
+    const formatTagDocId = parseArangoId(tagDocId);
+    const formatItemDocId = parseArangoId(itemDocId);
+    const edgeId = createHash(`isTagged-${formatTagDocId}-${formatItemDocId}`);
+    const edgeCollection = useDb(databaseName).collection('isTagged');
+    const type = formatItemDocId.split('/')[0];
+    const formatTagBy = parseId(tagBy) || sessionId || '';
+    const edge = {
+        _from: formatTagDocId,
+        _key: edgeId,
+        _to: formatItemDocId,
+        added,
+        tagBy: formatTagBy,
+        type
+    };
+    await edgeCollection.save(edge, {
+        overwriteMode: 'ignore',
+        returnNew: true,
+        silent: true
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            params: {
+                edge
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+    const tagQuery = aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;
+    return useDb(databaseName).query(tagQuery).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            params: {
+                edge
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+};
+export const updateTag = (context, tag)=>{
+    const action = 'updateTag';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const now = Date.now();
+    const { description, name, tagId } = parseTag(tag);
+    const formatName = parseVarChar(name, 32);
+    const update = {
+        description: parseVarChar(description, 64),
+        modified: now,
+        name: formatName
+    };
+    const newTagKey = tagId || createHash(`tag-${formatName.toLowerCase()}`);
+    const insert = {
+        ...update,
+        _id: `tags/${newTagKey}`,
+        _key: newTagKey,
+        added: now,
+        tagBy: sessionId
+    };
+    const aqlQry = aql`UPSERT {name: ${formatName}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN tags RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+};
+export const deleteTag = async (context, tag)=>{
+    const action = 'deleteTag';
+    const { databaseName } = context;
+    const formatItemId = getDocId('tags', tag);
+    const tagQuery = `FOR it FROM isTagged
+    FILTER it._from == "${formatItemId}" || it._to == "${formatItemId}"
+    REMOVE it IN isTagged
+    RETURN OLD`;
+    await useDb(databaseName).query(tagQuery).then((cursor)=>cursor.all()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+    const aqlQry = `LET t = DOCUMENT(${formatItemId})
+    REMOVE t IN tags
+    RETURN OLD`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+};
+export const deleteTagFromEdge = async (context, { tagDocId, edgeDocId })=>{
+    const action = 'deleteTagFromEdge';
+    const { databaseName } = context;
+    const formatTagDocId = parseArangoId(tagDocId);
+    const formatEdgeDocId = parseArangoId(edgeDocId);
+    const edgeCollection = useDb(databaseName).collection('isTagged');
+    const edge = {
+        _id: formatEdgeDocId
+    };
+    await edgeCollection.remove(edge, {
+        silent: true
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+    const tagQuery = aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;
+    return useDb(databaseName).query(tagQuery).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+};
+export const deleteTagFromItem = async (context, { tagId, itemId, itemType })=>{
+    const action = 'deleteTagFromItem';
+    const { databaseName } = context;
+    const formatTagDocId = parseArangoId(`tags/${tagId}`);
+    const formatItemDocId = parseArangoId(`${itemType}/${itemId}`);
+    const aqlQuery = `FOR it FROM isTagged
+    FILTER it._from == "${formatTagDocId}" || it._to == "${formatItemDocId}"
+    REMOVE it IN isTagged`;
+    return useDb(databaseName).query(aqlQuery).then(()=>true).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {});
+        return false;
+    });
+};
+export const extractTags = (content)=>words(content, /#[a-zA-Z\d-]+/g).map((tag)=>parseId(tag));
+export const updateTagsInItem = (context, { itemDocId, tags })=>{
+    const action = 'updateTagsInItem';
+    const { databaseName } = context;
+    const edgeCollection = useDb(databaseName).collection('isTagged');
+    return edgeCollection.inEdges(itemDocId, {}).then((edges)=>Promise.all([
+            ...edges.filter(({ name: existingTagName })=>!tags.find(({ name: tagName })=>existingTagName === tagName)).map(({ _id: edgeDocId, _from: tagDocId })=>deleteTagFromEdge(context, {
+                    edgeDocId,
+                    tagDocId
+                })),
+            ...tags.filter(({ name: tagName })=>!edges.find(({ name: existingTagName })=>existingTagName === tagName)).map(({ _id: tagDocId = '', tagBy })=>addTagToItem(context, {
+                    itemDocId,
+                    tagBy,
+                    tagDocId
+                }))
+        ]).then(()=>tags)).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, {}));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/tags.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {createHash, parseArangoId, parseId, parseVarChar} from '@nlabs/utils/parsers/strings';\nimport {words} from '@nlabs/utils/strings/words';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {Edge} from 'arangojs/documents';\n\nimport {parseTag} from '../adapters/tagAdapter.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {getDocId, getLimit, useDb} from '../utils/arangodbUtils.js';\n\nimport type {EdgeCollection} from 'arangojs/collections';\nimport type {ArangoDbLimit} from '../types/arangodb.types.js';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {IsTaggedType, TagType} from '../types/tags.types.js';\n\nconst eventCategory: string = 'tags';\nexport interface TagOptions {\n  readonly from?: number;\n  readonly search?: string;\n  readonly to?: number;\n  readonly userId?: string;\n}\n\nexport const getTags = (\n  context: ApiContext,\n  options: TagOptions = {}\n): Promise<TagType[]> => {\n  const action: string = 'getList';\n  const {databaseName} = context;\n  const {search = '', from = 0, to = 30, userId} = options;\n  const limit: ArangoDbLimit = getLimit(from, to);\n\n  const filters: string[] = [];\n\n  if(search) {\n    filters.push(`LIKE(t.name, \"%${search}%\")`);\n  }\n\n  if(userId) {\n    filters.push(`t.userId == \"${userId}\"`);\n  }\n\n  const aqlQry: string = `FOR t IN tags\n    FILTER ${filters.join(' || ')}\n    ${limit.aql}\n    SORT t.name\n    RETURN t`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as TagType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n\n      return [] as TagType[];\n    });\n};\n\nexport const getTagsByItem = (\n  context: ApiContext,\n  itemDocId: string,\n  options: TagOptions = {}\n): Promise<TagType[]> => {\n  const action: string = 'getTagsByItem';\n  const {from = 0, to = 30} = options;\n  const {databaseName} = context;\n  const limit: ArangoDbLimit = getLimit(from, to);\n  const formatItemId: string = parseArangoId(itemDocId);\n  const tagQuery: string = `FOR t, it IN INBOUND \"${formatItemId}\" isTagged\n    ${limit.aql}\n    SORT it.added\n    RETURN t`;\n\n  return useDb(databaseName).query(tagQuery)\n    .then((cursor) => cursor.all() as unknown as TagType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n\n      return [] as TagType[];\n    });\n};\n\nexport const getTag = (context: ApiContext, tagId: string): Promise<TagType> => {\n  const action: string = 'getTag';\n  const {databaseName} = context;\n  const formatId: string = parseId(tagId);\n  const aqlQry: string = `FOR t IN tags\n    FILTER t._key == \"${formatId}\"\n    LIMIT 1\n    RETURN t`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const getTagsByName = (context: ApiContext, tagNames: string[]): Promise<TagType[]> => {\n  const action: string = 'getTagsByName';\n  const {databaseName} = context;\n  const formatTagNames = tagNames\n    .map((tagName) => parseVarChar(tagName, 32))\n    .filter((tagName) => !!tagName);\n\n  if(!formatTagNames.length) {\n    return Promise.resolve([]);\n  }\n\n  const aqlQry: AqlQuery = aql`FOR t IN tags\n    FILTER POSITION(${JSON.stringify(formatTagNames)}, t.name)\n    RETURN t`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as TagType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n\n      return [] as TagType[];\n    });\n};\n\nexport const addTag = (context: ApiContext, tag: TagType): Promise<TagType> => {\n  const action: string = 'addTag';\n  const {databaseName} = context;\n  const now: number = Date.now();\n  const {description, name} = parseTag(tag);\n  const formatId: string = createHash(`tag-${name?.toLowerCase()}`);\n  const insert: TagType = {\n    _key: formatId,\n    added: now,\n    description: parseVarChar(description, 64),\n    modified: now,\n    name: parseVarChar(name, 32)\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN tags RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const addTagToItem = async (\n  context: ApiContext,\n  {itemDocId, tagBy = '', tagDocId}: {itemDocId: string, tagBy?: string, tagDocId: string}\n): Promise<TagType> => {\n  const action: string = 'addTagToItem';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const added: number = Date.now();\n  const formatTagDocId: string = parseArangoId(tagDocId);\n  const formatItemDocId: string = parseArangoId(itemDocId);\n  const edgeId: string = createHash(`isTagged-${formatTagDocId}-${formatItemDocId}`);\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection('isTagged');\n  const type: string = formatItemDocId.split('/')[0];\n  const formatTagBy: string = parseId(tagBy) || sessionId || '';\n  const edge: Edge = {_from: formatTagDocId, _key: edgeId, _to: formatItemDocId, added, tagBy: formatTagBy, type};\n\n  await edgeCollection.save(edge, {overwriteMode: 'ignore', returnNew: true, silent: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {\n        edge\n      },\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n\n  const tagQuery: AqlQuery = aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;\n\n  return useDb(databaseName).query(tagQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {\n        edge\n      },\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const updateTag = (context: ApiContext, tag: TagType): Promise<TagType> => {\n  const action: string = 'updateTag';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const now: number = Date.now();\n  const {description, name, tagId} = parseTag(tag);\n  const formatName: string = parseVarChar(name, 32);\n  const update: TagType = {\n    description: parseVarChar(description, 64),\n    modified: now,\n    name: formatName\n  };\n  const newTagKey: string = tagId || createHash(`tag-${formatName.toLowerCase()}`);\n  const insert: TagType = {\n    ...update,\n    _id: `tags/${newTagKey}`,\n    _key: newTagKey,\n    added: now,\n    tagBy: sessionId\n  };\n  const aqlQry: AqlQuery = aql`UPSERT {name: ${formatName}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN tags RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const deleteTag = async (context: ApiContext, tag: TagType): Promise<TagType> => {\n  const action: string = 'deleteTag';\n  const {databaseName} = context;\n  const formatItemId = getDocId('tags', tag);\n  const tagQuery: string = `FOR it FROM isTagged\n    FILTER it._from == \"${formatItemId}\" || it._to == \"${formatItemId}\"\n    REMOVE it IN isTagged\n    RETURN OLD`;\n\n  await useDb(databaseName).query(tagQuery)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n\n  const aqlQry = `LET t = DOCUMENT(${formatItemId})\n    REMOVE t IN tags\n    RETURN OLD`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const deleteTagFromEdge = async (context: ApiContext, {tagDocId, edgeDocId}): Promise<TagType> => {\n  const action = 'deleteTagFromEdge';\n  const {databaseName} = context;\n  const formatTagDocId = parseArangoId(tagDocId);\n  const formatEdgeDocId = parseArangoId(edgeDocId);\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection('isTagged');\n  const edge = {_id: formatEdgeDocId};\n\n  await edgeCollection.remove(edge, {silent: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n\n  const tagQuery: AqlQuery = aql`LET t = DOCUMENT(${formatTagDocId}) RETURN t`;\n\n  return useDb(databaseName).query(tagQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n\nexport const deleteTagFromItem = async (context: ApiContext, {tagId, itemId, itemType}): Promise<boolean> => {\n  const action = 'deleteTagFromItem';\n  const {databaseName} = context;\n  const formatTagDocId = parseArangoId(`tags/${tagId}`);\n  const formatItemDocId = parseArangoId(`${itemType}/${itemId}`);\n\n  const aqlQuery: string = `FOR it FROM isTagged\n    FILTER it._from == \"${formatTagDocId}\" || it._to == \"${formatItemDocId}\"\n    REMOVE it IN isTagged`;\n\n  return useDb(databaseName).query(aqlQuery)\n    .then(() => true)\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, {});\n\n      return false;\n    });\n};\n\nexport const extractTags = (content: string): string[] =>\n  words(content, /#[a-zA-Z\\d-]+/g).map((tag: string) => parseId(tag));\n\nexport const updateTagsInItem = (context: ApiContext, {itemDocId, tags}): Promise<TagType[]> => {\n  const action = 'updateTagsInItem';\n  const {databaseName} = context;\n  const edgeCollection = useDb(databaseName).collection('isTagged') as EdgeCollection<TagType>;\n\n  return edgeCollection.inEdges(itemDocId, {})\n    .then((edges) => Promise.all([\n      ...(edges as unknown as IsTaggedType[])\n        .filter(({name: existingTagName}) => !tags.find(({name: tagName}) => existingTagName === tagName))\n        .map(({_id: edgeDocId, _from: tagDocId}) => deleteTagFromEdge(context, {edgeDocId, tagDocId})),\n      ...(tags as unknown as TagType[])\n        .filter(({name: tagName}) => !(edges as unknown as IsTaggedType[])\n          .find(({name: existingTagName}) => existingTagName === tagName))\n        .map(({_id: tagDocId = '', tagBy}) => addTagToItem(context, {itemDocId, tagBy, tagDocId}))\n    ])\n      .then(() => tags))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, {}));\n};\n"],"names":["createHash","parseArangoId","parseId","parseVarChar","words","aql","parseTag","ErrorTypes","logError","getDocId","getLimit","useDb","eventCategory","getTags","context","options","action","databaseName","search","from","to","userId","limit","filters","push","aqlQry","join","query","then","cursor","all","catch","error","category","value","DATABASE_ERROR","getTagsByItem","itemDocId","formatItemId","tagQuery","getTag","tagId","formatId","next","getTagsByName","tagNames","formatTagNames","map","tagName","filter","length","Promise","resolve","JSON","stringify","addTag","tag","now","Date","description","name","toLowerCase","insert","_key","added","modified","addTagToItem","tagBy","tagDocId","session","sessionId","formatTagDocId","formatItemDocId","edgeId","edgeCollection","collection","type","split","formatTagBy","edge","_from","_to","save","overwriteMode","returnNew","silent","params","updateTag","formatName","update","newTagKey","_id","deleteTag","deleteTagFromEdge","edgeDocId","formatEdgeDocId","remove","deleteTagFromItem","itemId","itemType","aqlQuery","extractTags","content","updateTagsInItem","tags","inEdges","edges","existingTagName","find"],"mappings":"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"}

package/lib/actions/users.d.ts

@@ -71,3 +71,4 @@ export declare const signOut: (context: ApiContext) => Promise<boolean>;
 export declare const getActiveUserCount: (context: ApiContext) => Promise<number>;
 export declare const getUserByToken: (context: ApiContext, token: string) => Promise<UserType>;
 export {};
+//# sourceMappingURL=users.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../src/actions/users.ts"],"names":[],"mappings":"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"}