@junobuild/admin 0.0.12 → 0.0.14

package/declarations/frontend/frontend.did

@@ -0,0 +1,188 @@
+type BatchId = nat;
+type ChunkId = nat;
+type Key = text;
+type Time = int;
+
+type CreateAssetArguments = record {
+  key: Key;
+  content_type: text;
+  max_age: opt nat64;
+  headers: opt vec HeaderField;
+  enable_aliasing: opt bool;
+  allow_raw_access: opt bool;
+};
+
+// Add or change content for an asset, by content encoding
+type SetAssetContentArguments = record {
+  key: Key;
+  content_encoding: text;
+  chunk_ids: vec ChunkId;
+  sha256: opt blob;
+};
+
+// Remove content for an asset, by content encoding
+type UnsetAssetContentArguments = record {
+  key: Key;
+  content_encoding: text;
+};
+
+// Delete an asset
+type DeleteAssetArguments = record {
+  key: Key;
+};
+
+// Reset everything
+type ClearArguments = record {};
+
+type BatchOperationKind = variant {
+  CreateAsset: CreateAssetArguments;
+  SetAssetContent: SetAssetContentArguments;
+
+  UnsetAssetContent: UnsetAssetContentArguments;
+  DeleteAsset: DeleteAssetArguments;
+
+  Clear: ClearArguments;
+};
+
+type HeaderField = record { text; text; };
+
+type HttpRequest = record {
+  method: text;
+  url: text;
+  headers: vec HeaderField;
+  body: blob;
+};
+
+type HttpResponse = record {
+  status_code: nat16;
+  headers: vec HeaderField;
+  body: blob;
+  streaming_strategy: opt StreamingStrategy;
+};
+
+type StreamingCallbackHttpResponse = record {
+  body: blob;
+  token: opt StreamingCallbackToken;
+};
+
+type StreamingCallbackToken = record {
+  key: Key;
+  content_encoding: text;
+  index: nat;
+  sha256: opt blob;
+};
+
+type StreamingStrategy = variant {
+  Callback: record {
+    callback: func (StreamingCallbackToken) -> (opt StreamingCallbackHttpResponse) query;
+    token: StreamingCallbackToken;
+  };
+};
+
+type SetAssetPropertiesArguments = record {
+  key: Key;
+  max_age: opt opt nat64;
+  headers: opt opt vec HeaderField;
+  allow_raw_access: opt opt bool;
+};
+
+type Permission = variant {
+  Commit;
+  ManagePermissions;
+  Prepare;
+};
+
+type GrantPermission = record {
+  to_principal: principal;
+  permission: Permission;
+};
+type RevokePermission = record {
+  of_principal: principal;
+  permission: Permission;
+};
+type ListPermitted = record { permission: Permission };
+
+type ValidationResult = variant { Ok : text; Err : text };
+
+service: {
+  get: (record {
+    key: Key;
+    accept_encodings: vec text;
+  }) -> (record {
+    content: blob; // may be the entirety of the content, or just chunk index 0
+    content_type: text;
+    content_encoding: text;
+    sha256: opt blob; // sha256 of entire asset encoding, calculated by dfx and passed in SetAssetContentArguments
+    total_length: nat; // all chunks except last have size == content.size()
+  }) query;
+
+  // if get() returned chunks > 1, call this to retrieve them.
+  // chunks may or may not be split up at the same boundaries as presented to create_chunk().
+  get_chunk: (record {
+    key: Key;
+    content_encoding: text;
+    index: nat;
+    sha256: opt blob;  // sha256 of entire asset encoding, calculated by dfx and passed in SetAssetContentArguments
+  }) -> (record { content: blob }) query;
+
+  list : (record {}) -> (vec record {
+    key: Key;
+    content_type: text;
+    encodings: vec record {
+      content_encoding: text;
+      sha256: opt blob; // sha256 of entire asset encoding, calculated by dfx and passed in SetAssetContentArguments
+      length: nat; // Size of this encoding's blob. Calculated when uploading assets.
+      modified: Time;
+    };
+  }) query;
+
+  certified_tree : (record {}) -> (record {
+    certificate: blob;
+    tree: blob;
+  }) query;
+
+  create_batch : (record {}) -> (record { batch_id: BatchId });
+
+  create_chunk: (record { batch_id: BatchId; content: blob }) -> (record { chunk_id: ChunkId });
+
+  // Perform all operations successfully, or reject
+  commit_batch: (record { batch_id: BatchId; operations: vec BatchOperationKind }) -> ();
+
+  create_asset: (CreateAssetArguments) -> ();
+  set_asset_content: (SetAssetContentArguments) -> ();
+  unset_asset_content: (UnsetAssetContentArguments) -> ();
+
+  delete_asset: (DeleteAssetArguments) -> ();
+
+  clear: (ClearArguments) -> ();
+
+  // Single call to create an asset with content for a single content encoding that
+  // fits within the message ingress limit.
+  store: (record {
+    key: Key;
+    content_type: text;
+    content_encoding: text;
+    content: blob;
+    sha256: opt blob
+  }) -> ();
+
+  http_request: (request: HttpRequest) -> (HttpResponse) query;
+  http_request_streaming_callback: (token: StreamingCallbackToken) -> (opt StreamingCallbackHttpResponse) query;
+
+  authorize: (principal) -> ();
+  deauthorize: (principal) -> ();
+  list_authorized: () -> (vec principal) query;
+  grant_permission: (GrantPermission) -> ();
+  revoke_permission: (RevokePermission) -> ();
+  list_permitted: (ListPermitted) -> (vec principal) query;
+  take_ownership: () -> ();
+
+  get_asset_properties : (key: Key) -> (record {
+    max_age: opt nat64;
+    headers: opt vec HeaderField;
+    allow_raw_access: opt bool; } ) query;
+  set_asset_properties: (SetAssetPropertiesArguments) -> ();
+
+  validate_grant_permission: (GrantPermission) -> (ValidationResult);
+  validate_revoke_permission: (RevokePermission) -> (ValidationResult);
+}

package/declarations/frontend/frontend.did.d.ts

@@ -0,0 +1,172 @@
+import type {ActorMethod} from '@dfinity/agent';
+import type {Principal} from '@dfinity/principal';
+
+export type BatchId = bigint;
+export type BatchOperationKind =
+  | {CreateAsset: CreateAssetArguments}
+  | {UnsetAssetContent: UnsetAssetContentArguments}
+  | {DeleteAsset: DeleteAssetArguments}
+  | {SetAssetContent: SetAssetContentArguments}
+  | {Clear: ClearArguments};
+export type ChunkId = bigint;
+export type ClearArguments = {};
+export interface CreateAssetArguments {
+  key: Key;
+  content_type: string;
+  headers: [] | [Array<HeaderField>];
+  allow_raw_access: [] | [boolean];
+  max_age: [] | [bigint];
+  enable_aliasing: [] | [boolean];
+}
+export interface DeleteAssetArguments {
+  key: Key;
+}
+export interface GrantPermission {
+  permission: Permission;
+  to_principal: Principal;
+}
+export type HeaderField = [string, string];
+export interface HttpRequest {
+  url: string;
+  method: string;
+  body: Uint8Array | number[];
+  headers: Array<HeaderField>;
+}
+export interface HttpResponse {
+  body: Uint8Array | number[];
+  headers: Array<HeaderField>;
+  streaming_strategy: [] | [StreamingStrategy];
+  status_code: number;
+}
+export type Key = string;
+export interface ListPermitted {
+  permission: Permission;
+}
+export type Permission = {Prepare: null} | {ManagePermissions: null} | {Commit: null};
+export interface RevokePermission {
+  permission: Permission;
+  of_principal: Principal;
+}
+export interface SetAssetContentArguments {
+  key: Key;
+  sha256: [] | [Uint8Array | number[]];
+  chunk_ids: Array<ChunkId>;
+  content_encoding: string;
+}
+export interface SetAssetPropertiesArguments {
+  key: Key;
+  headers: [] | [[] | [Array<HeaderField>]];
+  allow_raw_access: [] | [[] | [boolean]];
+  max_age: [] | [[] | [bigint]];
+}
+export interface StreamingCallbackHttpResponse {
+  token: [] | [StreamingCallbackToken];
+  body: Uint8Array | number[];
+}
+export interface StreamingCallbackToken {
+  key: Key;
+  sha256: [] | [Uint8Array | number[]];
+  index: bigint;
+  content_encoding: string;
+}
+export type StreamingStrategy = {
+  Callback: {
+    token: StreamingCallbackToken;
+    callback: [Principal, string];
+  };
+};
+export type Time = bigint;
+export interface UnsetAssetContentArguments {
+  key: Key;
+  content_encoding: string;
+}
+export type ValidationResult = {Ok: string} | {Err: string};
+export interface _SERVICE {
+  authorize: ActorMethod<[Principal], undefined>;
+  certified_tree: ActorMethod<
+    [{}],
+    {certificate: Uint8Array | number[]; tree: Uint8Array | number[]}
+  >;
+  clear: ActorMethod<[ClearArguments], undefined>;
+  commit_batch: ActorMethod<
+    [{batch_id: BatchId; operations: Array<BatchOperationKind>}],
+    undefined
+  >;
+  create_asset: ActorMethod<[CreateAssetArguments], undefined>;
+  create_batch: ActorMethod<[{}], {batch_id: BatchId}>;
+  create_chunk: ActorMethod<
+    [{content: Uint8Array | number[]; batch_id: BatchId}],
+    {chunk_id: ChunkId}
+  >;
+  deauthorize: ActorMethod<[Principal], undefined>;
+  delete_asset: ActorMethod<[DeleteAssetArguments], undefined>;
+  get: ActorMethod<
+    [{key: Key; accept_encodings: Array<string>}],
+    {
+      content: Uint8Array | number[];
+      sha256: [] | [Uint8Array | number[]];
+      content_type: string;
+      content_encoding: string;
+      total_length: bigint;
+    }
+  >;
+  get_asset_properties: ActorMethod<
+    [Key],
+    {
+      headers: [] | [Array<HeaderField>];
+      allow_raw_access: [] | [boolean];
+      max_age: [] | [bigint];
+    }
+  >;
+  get_chunk: ActorMethod<
+    [
+      {
+        key: Key;
+        sha256: [] | [Uint8Array | number[]];
+        index: bigint;
+        content_encoding: string;
+      }
+    ],
+    {content: Uint8Array | number[]}
+  >;
+  grant_permission: ActorMethod<[GrantPermission], undefined>;
+  http_request: ActorMethod<[HttpRequest], HttpResponse>;
+  http_request_streaming_callback: ActorMethod<
+    [StreamingCallbackToken],
+    [] | [StreamingCallbackHttpResponse]
+  >;
+  list: ActorMethod<
+    [{}],
+    Array<{
+      key: Key;
+      encodings: Array<{
+        modified: Time;
+        sha256: [] | [Uint8Array | number[]];
+        length: bigint;
+        content_encoding: string;
+      }>;
+      content_type: string;
+    }>
+  >;
+  list_authorized: ActorMethod<[], Array<Principal>>;
+  list_permitted: ActorMethod<[ListPermitted], Array<Principal>>;
+  revoke_permission: ActorMethod<[RevokePermission], undefined>;
+  set_asset_content: ActorMethod<[SetAssetContentArguments], undefined>;
+  set_asset_properties: ActorMethod<[SetAssetPropertiesArguments], undefined>;
+  store: ActorMethod<
+    [
+      {
+        key: Key;
+        content: Uint8Array | number[];
+        sha256: [] | [Uint8Array | number[]];
+        content_type: string;
+        content_encoding: string;
+      }
+    ],
+    undefined
+  >;
+  take_ownership: ActorMethod<[], undefined>;
+  unset_asset_content: ActorMethod<[UnsetAssetContentArguments], undefined>;
+  validate_grant_permission: ActorMethod<[GrantPermission], ValidationResult>;
+  validate_revoke_permission: ActorMethod<[RevokePermission], ValidationResult>;
+}

package/declarations/frontend/frontend.factory.did.js

@@ -0,0 +1,208 @@
+export const idlFactory = ({IDL}) => {
+  const ClearArguments = IDL.Record({});
+  const BatchId = IDL.Nat;
+  const Key = IDL.Text;
+  const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+  const CreateAssetArguments = IDL.Record({
+    key: Key,
+    content_type: IDL.Text,
+    headers: IDL.Opt(IDL.Vec(HeaderField)),
+    allow_raw_access: IDL.Opt(IDL.Bool),
+    max_age: IDL.Opt(IDL.Nat64),
+    enable_aliasing: IDL.Opt(IDL.Bool)
+  });
+  const UnsetAssetContentArguments = IDL.Record({
+    key: Key,
+    content_encoding: IDL.Text
+  });
+  const DeleteAssetArguments = IDL.Record({key: Key});
+  const ChunkId = IDL.Nat;
+  const SetAssetContentArguments = IDL.Record({
+    key: Key,
+    sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    chunk_ids: IDL.Vec(ChunkId),
+    content_encoding: IDL.Text
+  });
+  const BatchOperationKind = IDL.Variant({
+    CreateAsset: CreateAssetArguments,
+    UnsetAssetContent: UnsetAssetContentArguments,
+    DeleteAsset: DeleteAssetArguments,
+    SetAssetContent: SetAssetContentArguments,
+    Clear: ClearArguments
+  });
+  const Permission = IDL.Variant({
+    Prepare: IDL.Null,
+    ManagePermissions: IDL.Null,
+    Commit: IDL.Null
+  });
+  const GrantPermission = IDL.Record({
+    permission: Permission,
+    to_principal: IDL.Principal
+  });
+  const HttpRequest = IDL.Record({
+    url: IDL.Text,
+    method: IDL.Text,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField)
+  });
+  const StreamingCallbackToken = IDL.Record({
+    key: Key,
+    sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    index: IDL.Nat,
+    content_encoding: IDL.Text
+  });
+  const StreamingCallbackHttpResponse = IDL.Record({
+    token: IDL.Opt(StreamingCallbackToken),
+    body: IDL.Vec(IDL.Nat8)
+  });
+  const StreamingStrategy = IDL.Variant({
+    Callback: IDL.Record({
+      token: StreamingCallbackToken,
+      callback: IDL.Func(
+        [StreamingCallbackToken],
+        [IDL.Opt(StreamingCallbackHttpResponse)],
+        ['query']
+      )
+    })
+  });
+  const HttpResponse = IDL.Record({
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField),
+    streaming_strategy: IDL.Opt(StreamingStrategy),
+    status_code: IDL.Nat16
+  });
+  const Time = IDL.Int;
+  const ListPermitted = IDL.Record({permission: Permission});
+  const RevokePermission = IDL.Record({
+    permission: Permission,
+    of_principal: IDL.Principal
+  });
+  const SetAssetPropertiesArguments = IDL.Record({
+    key: Key,
+    headers: IDL.Opt(IDL.Opt(IDL.Vec(HeaderField))),
+    allow_raw_access: IDL.Opt(IDL.Opt(IDL.Bool)),
+    max_age: IDL.Opt(IDL.Opt(IDL.Nat64))
+  });
+  const ValidationResult = IDL.Variant({Ok: IDL.Text, Err: IDL.Text});
+  return IDL.Service({
+    authorize: IDL.Func([IDL.Principal], [], []),
+    certified_tree: IDL.Func(
+      [IDL.Record({})],
+      [
+        IDL.Record({
+          certificate: IDL.Vec(IDL.Nat8),
+          tree: IDL.Vec(IDL.Nat8)
+        })
+      ],
+      ['query']
+    ),
+    clear: IDL.Func([ClearArguments], [], []),
+    commit_batch: IDL.Func(
+      [
+        IDL.Record({
+          batch_id: BatchId,
+          operations: IDL.Vec(BatchOperationKind)
+        })
+      ],
+      [],
+      []
+    ),
+    create_asset: IDL.Func([CreateAssetArguments], [], []),
+    create_batch: IDL.Func([IDL.Record({})], [IDL.Record({batch_id: BatchId})], []),
+    create_chunk: IDL.Func(
+      [IDL.Record({content: IDL.Vec(IDL.Nat8), batch_id: BatchId})],
+      [IDL.Record({chunk_id: ChunkId})],
+      []
+    ),
+    deauthorize: IDL.Func([IDL.Principal], [], []),
+    delete_asset: IDL.Func([DeleteAssetArguments], [], []),
+    get: IDL.Func(
+      [IDL.Record({key: Key, accept_encodings: IDL.Vec(IDL.Text)})],
+      [
+        IDL.Record({
+          content: IDL.Vec(IDL.Nat8),
+          sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          content_type: IDL.Text,
+          content_encoding: IDL.Text,
+          total_length: IDL.Nat
+        })
+      ],
+      ['query']
+    ),
+    get_asset_properties: IDL.Func(
+      [Key],
+      [
+        IDL.Record({
+          headers: IDL.Opt(IDL.Vec(HeaderField)),
+          allow_raw_access: IDL.Opt(IDL.Bool),
+          max_age: IDL.Opt(IDL.Nat64)
+        })
+      ],
+      ['query']
+    ),
+    get_chunk: IDL.Func(
+      [
+        IDL.Record({
+          key: Key,
+          sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          index: IDL.Nat,
+          content_encoding: IDL.Text
+        })
+      ],
+      [IDL.Record({content: IDL.Vec(IDL.Nat8)})],
+      ['query']
+    ),
+    grant_permission: IDL.Func([GrantPermission], [], []),
+    http_request: IDL.Func([HttpRequest], [HttpResponse], ['query']),
+    http_request_streaming_callback: IDL.Func(
+      [StreamingCallbackToken],
+      [IDL.Opt(StreamingCallbackHttpResponse)],
+      ['query']
+    ),
+    list: IDL.Func(
+      [IDL.Record({})],
+      [
+        IDL.Vec(
+          IDL.Record({
+            key: Key,
+            encodings: IDL.Vec(
+              IDL.Record({
+                modified: Time,
+                sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+                length: IDL.Nat,
+                content_encoding: IDL.Text
+              })
+            ),
+            content_type: IDL.Text
+          })
+        )
+      ],
+      ['query']
+    ),
+    list_authorized: IDL.Func([], [IDL.Vec(IDL.Principal)], ['query']),
+    list_permitted: IDL.Func([ListPermitted], [IDL.Vec(IDL.Principal)], ['query']),
+    revoke_permission: IDL.Func([RevokePermission], [], []),
+    set_asset_content: IDL.Func([SetAssetContentArguments], [], []),
+    set_asset_properties: IDL.Func([SetAssetPropertiesArguments], [], []),
+    store: IDL.Func(
+      [
+        IDL.Record({
+          key: Key,
+          content: IDL.Vec(IDL.Nat8),
+          sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          content_type: IDL.Text,
+          content_encoding: IDL.Text
+        })
+      ],
+      [],
+      []
+    ),
+    take_ownership: IDL.Func([], [], []),
+    unset_asset_content: IDL.Func([UnsetAssetContentArguments], [], []),
+    validate_grant_permission: IDL.Func([GrantPermission], [ValidationResult], []),
+    validate_revoke_permission: IDL.Func([RevokePermission], [ValidationResult], [])
+  });
+};
+export const init = ({IDL}) => {
+  return [];
+};

package/declarations/frontend/index.d.ts

@@ -0,0 +1,45 @@
+import type {ActorConfig, ActorSubclass, Agent, HttpAgentOptions} from '@dfinity/agent';
+import type {IDL} from '@dfinity/candid';
+import type {Principal} from '@dfinity/principal';
+
+import {_SERVICE} from './frontend.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const frontend: ActorSubclass<_SERVICE>;

package/declarations/frontend/index.js

@@ -0,0 +1,32 @@
+import {Actor, HttpAgent} from '@dfinity/agent';
+
+// Imports and re-exports candid interface
+import {idlFactory} from './frontend.did.js';
+export {idlFactory} from './frontend.did.js';
+
+// CANISTER_ID is replaced by webpack based on node environment
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({...options.agentOptions});
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      'Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent.'
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== 'ic') {
+    agent.fetchRootKey().catch((err) => {
+      console.warn('Unable to fetch root key. Check to ensure that your local replica is running');
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions
+  });
+};