Migrating to the Koji core package

// Retrieve a short-lived user token to exchange on the backend
const getToken = async () => {
  const { userToken, presumedRole, presumedAttributes } = await Koji.identity.getToken();
};

// Silently request whether a user has already granted a set of permissions
const checkGrants = async () => {
  const hasGrants = await Koji.identity.checkGrants(['push_notifications', 'username']);
};

// Open a dialog to request new permissions from the user (and return a user token)
const requestGrants = async () => {
  const userToken = await Koji.identity.requestGrants(['push_notifications', 'username']);
};

...
app.get('/get-user-role', async (req, res) => {
  const identity = new KojiBackend.Identity({ res });

  // Get the user token (generated using the frontend identity module)
  const userToken = req.headers.authorization;

  // Resolve the user
  const user = await identity.resolveUserFromToken(userToken);

  const {
    id,           // The userId (specific to the template/remix)
    attributes,   // Attributes about the user (username, etc.)
    dateCreated,  // When the user first shared information
    grants,       // Any permissions the user has granted
    role,         // The user's role
  } = user;

  res.status(200).json({
    role,
  });
});
...

...

app.get('/set-item', async (req, res) => {
  const database = new KojiBackend.Database({ res });

  // Get some data from the user
  const { item } = req.body;

  // Write the item to the database with a unique id
  const update = await database.set('items', 'unique-id', item);

  // Return the item
  res.status(200).json({
    item: update,
  });
});
...

const connection = await Koji.dispatch.connect();

console.log(connection); // Connection details include client ID and shard name

Koji.dispatch.on('message', (payload) => doSomething(payload));

Koji.dispatch.disconnect();

...
app.get('/dispatch-event', async (req, res) => {
  const dispatch = new KojiBackend.Dispatch({ res });

  // Wait for a connection (`connection` will have information about the connection)
  const connection = await dispatch.connect({});

  // Send a message to all connected users (in the scope of the template/remix)
  dispatch.emitEvent('test', { hello: 'world' });

  res.status(200).json({
    messageSent: true,
  });
});
...

const startPurchase = async () => {
  const purchase = await Koji.iap.startPurchase('productSku');

  if (purchase.receiptId) {
    // Success
    fetch(`${Koji.services.backend}/receipts-by-user`, {
      headers: {
        'Content-Type': 'application/json',
        authorization: purchase.iapToken,
      },
    })
    // Handle JSON
    .then(response => response.json())
    // Log receipts
    .then(data => console.log(data));
  } else {
    // User cancelled transaction
  }
};

const startDynamicPurchase = async () => {
  const purchase = await Koji.iap.startPurchase('dynamicProductSku',
    {
      amount: 17,
      customMessage: 'This is a custom message'.
    },
  );

  if (purchase.receiptId) {
    // Success
    fetch(`${Koji.services.backend}/receipts-by-user`, {
      headers: {
        'Content-Type': 'application/json',
        authorization: purchase.iapToken,
      },
    })
    // Handle JSON
    .then(response => response.json())
    // Log receipts
    .then(data => console.log(data));
  } else {
    // User cancelled transaction
  }
};

...
app.get('/receipts-by-user', async (req, res) => {
  const iap = new KojiBackend.IAP({ res });

  // Get the IAP token (generated using the frontend IAP module)
  const iapToken = req.headers.authorization;

  // Get receipts by user
  const receipts = await iap.resolveReceiptsByIAPToken(iapToken);

  res.status(200).json({
    receipts,
  });
});
...

const { context, receiptType } = Koji.playerState;

// Possible context values: 'about' | 'admin' | 'remix' | 'sticker' | 'receipt' | 'screenshot' | 'default'

// Possible receiptType values: 'buyer' | 'seller'

const unsubscribe = Koji.playerState.subscribe((isRemixing, editorAttributes) => {
  setSomeState(isRemixing);
  // Change Koji experience
});

// To remove listeners on unmount etc.
unsubscribe();

const backgroundColor = instantRemixing.get(['general', 'backgroundColor']);

import Koji from '@withkoji/core';

const remixData = Koji.remix.get();

const { backgroundColor } = remixData;

const imageURL = await Koji.ui.capture.image();

Koji.remix.set({ backgroundImage: imageURL });

const data = Koji.remix.get(); // { textColor: '#000000' }

Koji.remix.set({ backgroundImage: 'https://myImage.com/hello.jpg' });

const newData = Koji.remix.get(); // { textColor: '#000000',  backgroundImage: 'https://myImage.com/hello.jpg' }

Koji.remix.overwrite({
  backgroundImage: 'someValue',
  textColor: '#000000',
});

const onFinish = async () => {
  await Koji.remix.set({
    ...this.state, // Just an example where the state reflects remixData
  });

  Koji.remix.finish();
};

const backendURL = instantRemixing.get(['serviceMap', 'backend']);

const backendURL = Koji.services.backend

const storeSecretImage = async () => {
  // Capture an image (e.g., https://images.koji-cdn.com/my-image.png)
  const image = await Koji.ui.capture.image();

  // Make sure the user has chosen an image
  if (!image) return;

  // Get an encrypted value (e.g., $secret_xyz)
  const encryptedValue = await Koji.remix.encryptValue(image);

  // Store the value
  await Koji.remix.set({ secretImage: encryptedValue });
};

...
import kojiConfig from '../../koji.json';

// Create server
const app = express();

// Koji Middleware
app.use(KojiBackend.middleware(kojiConfig));

app.post('/resolve-secret', async (req, res, next) => {
  // Init
  const secret = new KojiBackend.Secret({ res });

  // Pass the encrypted value in the request body
  const decryptedValue = await secret.resolveValue(req.body.encryptedValue);

  // Pass back the decrypted value (https://images.koji-cdn.com/my-image.png)
  res.status(200).json({
    decryptedValue,
  });
});