Groups as permission scopes

Every CoValue has an owner, which can be a Group or an Account.

You can use a Group to grant access to a CoValue to multiple users. These users can have different roles, such as "writer", "reader" or "admin".

Creating a Group

Here's how you can create a Group.

import { class Group@categoryIdentity & PermissionsGroup } from "jazz-tools";

const const group: Groupgroup = class Group@categoryIdentity & PermissionsGroup.Group.create<Group>(this: CoValueClass<Group>, options?: {
    owner: Account;
} | Account): Groupcreate();

The Group itself is a CoValue, and whoever owns it is the initial admin.

You typically add members using public sharing or invites. But if you already know their ID, you can add them directly (see below).

Adding group members by ID

You can add group members by ID by using Account.load and Group.addMember.

import { class Group@categoryIdentity & PermissionsGroup, import coco } from "jazz-tools";

const const group: Groupgroup = class Group@categoryIdentity & PermissionsGroup.Group.create<Group>(this: CoValueClass<Group>, options?: {
    owner: Account;
} | Account): Groupcreate();

const const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | nullbob = await import coco.account<{
    profile: AnyCoMapSchema<{
        name: $ZodString<string>;
        inbox?: $ZodOptional<$ZodString>;
        inboxInvite?: $ZodOptional<$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>(shape?: {
    profile: AnyCoMapSchema<{
        name: $ZodString<string>;
        inbox?: $ZodOptional<$ZodString>;
        inboxInvite?: $ZodOptional<$ZodString>;
    }>;
    root: AnyCoMapSchema;
} | undefined): AccountSchema<...>
export accountaccount().load: <ResolveQuery<AccountSchema<{
    profile: AnyCoMapSchema<{
        name: $ZodString<string>;
        inbox?: $ZodOptional<$ZodString>;
        inboxInvite?: $ZodOptional<$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>>>(id: string, options?: {
    ...;
} | undefined) => Promise<...>load(const bobsID: "co_z123"bobsID);

if (const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | nullbob) {
  const group: Groupgroup.Group.addMember(member: Account, role: AccountRole): void (+2 overloads)addMember(const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account)bob, "writer");
}

Note: if the account ID is of type string, because it comes from a URL parameter or something similar, you need to cast it to ID<Account> first:

import { import coco, class Group@categoryIdentity & PermissionsGroup } from "jazz-tools";

const const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | nullbob = await import coco.account<{
    profile: AnyCoMapSchema<{
        name: $ZodString<string>;
        inbox?: $ZodOptional<$ZodString>;
        inboxInvite?: $ZodOptional<$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>(shape?: {
    profile: AnyCoMapSchema<{
        name: $ZodString<string>;
        inbox?: $ZodOptional<$ZodString>;
        inboxInvite?: $ZodOptional<$ZodString>;
    }>;
    root: AnyCoMapSchema;
} | undefined): AccountSchema<...>
export accountaccount().load: <ResolveQuery<AccountSchema<{
    profile: AnyCoMapSchema<{
        name: $ZodString<string>;
        inbox?: $ZodOptional<$ZodString>;
        inboxInvite?: $ZodOptional<$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>>>(id: string, options?: {
    ...;
} | undefined) => Promise<...>load(const bobsID: "co_z123"bobsID);

if (const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | nullbob) {
  const group: Groupgroup.Group.addMember(member: Account, role: AccountRole): void (+2 overloads)addMember(const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account)bob, "writer");
}

Changing a member's role

To change a member's role, use the addMember method.

const group: Groupgroup.Group.addMember(member: Account, role: AccountRole): void (+2 overloads)addMember(const bob: Account | ({
    [x: string]: any;
} & Account)bob, "reader");

Bob just went from a writer to a reader.

Note: only admins can change a member's role.

Removing a member

To remove a member, use the removeMember method.

const group: Groupgroup.Group.removeMember(member: Everyone | Account): Promise<void> (+1 overload)removeMember(const bob: Account | ({
    [x: string]: any;
} & Account)bob);

Rules:

All roles can remove themselves.
Only admins can remove other users.
An admin cannot remove other admins.
As an admin, you cannot remove yourself if you are the only admin in the Group, because there has to be at least one admin present.

Getting the Group of an existing CoValue

You can get the group of an existing CoValue by using coValue._owner.

const const group: Accountgroup = const existingCoValue: Account | ({
    [x: string]: any;
} & Account)existingCoValue.Account._owner: Account@categoryCollaboration_owner;
const const newValue: {
    color: string;
} & CoMapnewValue = const MyCoMap: CoMapSchema<{
    color: z.z.ZodString;
}>MyCoMap.create: (init: {
    color: string;
}, options?: Account | Group | {
    owner: Account | Group;
    unique?: CoValueUniqueness["uniqueness"];
} | undefined) => {
    ...;
} & CoMapcreate(
  { color: stringcolor: "red"},
  { owner: Account | Groupowner: const group: Accountgroup }
);

Because ._owner can be an co.account or a Group, in cases where you specifically need to use Group methods (such as for adding members or getting your own role), you can cast it to assert it to be a Group:

import { class Group@categoryIdentity & PermissionsGroup } from "jazz-tools";

const const group: Groupgroup = const existingCoValue: {
    color: string;
} & CoMapexistingCoValue.CoValueBase._owner: Group | Account@categoryCollaboration_owner.CoValueBase.castAs<typeof Group>(schema: typeof Group): Group@categoryType HelperscastAs(class Group@categoryIdentity & PermissionsGroup);
const group: Groupgroup.Group.addMember(member: Account, role: AccountRole): void (+2 overloads)addMember(const bob: Account | ({
    [x: string]: any;
} & Account)bob, "writer");

const const role: Role | undefinedrole = const group: Groupgroup.Group.getRoleOf(member: Everyone | ID<Account> | "me"): Role | undefinedgetRoleOf(const bob: Account | ({
    [x: string]: any;
} & Account)bob.Account.id: string@categoryContentid);

Checking the permissions

You can check the permissions of an account on a CoValue by using the canRead, canWrite and canAdmin methods.

const const value: {
    color: string;
} & CoMapvalue = await const MyCoMap: CoMapSchema<{
    color: z.z.ZodString;
}>MyCoMap.create: (init: {
    color: string;
}, options?: Account | Group | {
    owner: Account | Group;
    unique?: CoValueUniqueness["uniqueness"];
} | undefined) => {
    ...;
} & CoMapcreate({ color: stringcolor: "red"})
const const me: AccountInstanceCoValuesNullable<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>me = await import coco.account<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>(shape?: {
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
} | undefined): AccountSchema<...>
export accountaccount().getMe: () => AccountInstanceCoValuesNullable<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>getMe();

if (const me: AccountInstanceCoValuesNullable<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>me.Account.canAdmin(value: CoValue): booleancanAdmin(const value: {
    color: string;
} & CoMapvalue)) {
  var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("I can share value with others"); 
} else if (const me: AccountInstanceCoValuesNullable<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>me.Account.canWrite(value: CoValue): booleancanWrite(const value: {
    color: string;
} & CoMapvalue)) {
  var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("I can edit value");
} else if (const me: AccountInstanceCoValuesNullable<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>me.Account.canRead(value: CoValue): booleancanRead(const value: {
    color: string;
} & CoMapvalue)) {
  var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("I can view value");
} else {
  var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("I cannot access value");
}

To check the permissions of another account, you need to load it first:

const const value: {
    color: string;
} & CoMapvalue = await const MyCoMap: CoMapSchema<{
    color: z.z.ZodString;
}>MyCoMap.create: (init: {
    color: string;
}, options?: Account | Group | {
    owner: Account | Group;
    unique?: CoValueUniqueness["uniqueness"];
} | undefined) => {
    ...;
} & CoMapcreate({ color: stringcolor: "red"})
const const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | nullbob = await import coco.account<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>(shape?: {
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
} | undefined): AccountSchema<...>
export accountaccount().load: <ResolveQuery<AccountSchema<{
    profile: AnyCoMapSchema<{
        name: z.z.core.$ZodString<string>;
        inbox?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
        inboxInvite?: z.z.core.$ZodOptional<z.z.core.$ZodString>;
    }>;
    root: AnyCoMapSchema;
}>>>(id: string, options?: {
    ...;
} | undefined) => Promise<...>load(const accountID: stringaccountID);

if (const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account) | nullbob) {
  if (const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account)bob.Account.canAdmin(value: CoValue): booleancanAdmin(const value: {
    color: string;
} & CoMapvalue)) {
    var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("Bob can share value with others");
  } else if (const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account)bob.Account.canWrite(value: CoValue): booleancanWrite(const value: {
    color: string;
} & CoMapvalue)) {
    var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("Bob can edit value");
  } else if (const bob: ({
    profile: ({
        name: string;
        inbox?: string | undefined;
        inboxInvite?: string | undefined;
    } & CoMap) | null;
    root: ({
        [x: string]: any;
    } & CoMap) | null;
} & Account) | ({
    ...;
} & ... 1 more ... & Account)bob.Account.canRead(value: CoValue): booleancanRead(const value: {
    color: string;
} & CoMapvalue)) {
    var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("Bob can view value");
  } else {
    var console: ConsoleThe `console` module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.

The module exports two specific components:

* A `Console` class with methods such as `console.log()`, `console.error()` and `console.warn()` that can be used to write to any Node.js stream.
* A global `console` instance configured to write to [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) and
[`process.stderr`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstderr). The global `console` can be used without importing the `node:console` module.

_**Warning**_: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the [`note on process I/O`](https://nodejs.org/docs/latest-v20.x/api/process.html#a-note-on-process-io) for
more information.

Example using the global `console`:

```js
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
```

Example using the `Console` class:

```js
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
```
@see[source](https://github.com/nodejs/node/blob/v20.11.1/lib/console.js)console.Console.log(message?: any, ...optionalParams: any[]): void (+2 overloads)[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)log("Bob cannot access value");
  }
}

Docs issue?⌝Join Discord⌝

History

Public sharing & invites

Groups as permission scopes

#Creating a Group

#Adding group members by ID

#Changing a member's role

#Removing a member