TypeScript ObjectID.toString方法代码示例

      const addIdsToQueryMap = (access: boolean) => (id: string | ObjectID) => {
        const accessString = access ? 'positive' : 'negative';
        const altAccessString = access ? 'negative' : 'positive';
        const resourceUid = Tyr.byName[linkedCollectionName].idToUid(id);

        if (alreadySet.has(resourceUid)) {
          return;
        } else {
          alreadySet.add(resourceUid);
        }

        const accessSet =
          queryMaps[accessString].get(linkedCollectionName) || new Set();
        if (!queryMaps[accessString].has(linkedCollectionName)) {
          queryMaps[accessString].set(linkedCollectionName, accessSet);
        }

        // if the id was set previously, by a lower level link,
        // dont override the lower level
        const map = queryMaps[altAccessString].get(linkedCollectionName);

        if (!map || !map.has(id.toString())) {
          accessSet.add(id as string);
        }
      };

	connection.on('message', async (data) => {
		const msg = JSON.parse(data.utf8Data);

		switch (msg.type) {
			case 'read':
					if (!msg.id) {
						return;
					}

					const id = new mongodb.ObjectID(msg.id);

					// Fetch message
					// SELECT _id, user_id, is_read
					const message = await Message.findOne({
						_id: id,
						recipient_id: user._id
					}, {
						fields: {
							_id: true,
							user_id: true,
							is_read: true
						}
					});

					if (message == null) {
						return;
					}

					if (message.is_read) {
						return;
					}

					// Update documents
					await Message.update({
						_id: id
					}, {
						$set: { is_read: true }
					});

					// Publish event
					publishMessagingStream(message.user_id, user._id, 'read', id.toString());
				break;
		}
	});

/**
 * given a node in the debug graph,
 * find the path of nodes leading to a permission
 */
function getExplainationsForId(
  id: ObjectID,
  subjectId: string,
  subjectGraph: Map<string, string[]>,
  graph: DebugGraph,
  type: ExplainationType,
  property: string
): Explaination[] {
  const node = graph.get(id.toString());

  if (!node) {
    throw new Error(`No node found for id = ${id}`);
  }

  const nodeUid = toUid(node.collectionName, id);

  const out: Explaination[] = [];

  /**
   * the node itself represents a direct permission
   */
  if (!('parents' in node)) {
    const subjectPaths = getSubjectPaths(
      subjectId,
      node.subjectId,
      subjectGraph
    );
    const resourcePath = [nodeUid];

    for (const path of subjectPaths) {
      out.push({
        permissionId: node.permission.toString(),
        subjectPath: path,
        permissionType: node.type,
        property,
        resourcePath,
        type: ExplainationType.ALLOW
      });
    }

    return out;
  }

  /**
   * recurse up parent chain, building explaination objects with uid path
   */

  let currentNodes = [
    {
      type,
      resourcePath: [nodeUid],
      parents: Array.from(node.parents)
    }
  ];

  while (currentNodes.length) {
    const nextNodes: (Explaination & { parents: string[] })[] = [];

    for (const current of currentNodes) {
      const { parents, resourcePath } = current;

      for (const parent of parents) {
        const next = graph.get(parent);

        if (!next) {
          throw new Error(`No node found for parentId = ${parent}`);
        }

        const parentUid = toUid(next.collectionName, parent);
        const nextPath = [...resourcePath, parentUid];

        if (!('parents' in next)) {
          const subjectPaths = getSubjectPaths(
            subjectId,
            next.subjectId,
            subjectGraph
          );

          for (const subjectPath of subjectPaths) {
            out.push({
              type,
              resourcePath: nextPath,
              subjectPath,
              permissionId: next.permission.toString(),
              permissionType: next.type,
              property
            });
          }
        } else {
          nextNodes.push({
            type,
            resourcePath: nextPath,
            subjectPath: [],
            parents: Array.from(next.parents)
          });
        }
//.........这里部分代码省略.........

 get id(): string {
   return this._id.toString();
 }