@saleor/app-sdk/APL/dynamodb/index.js

SDK for building great Saleor Apps

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }

var _chunkVTKKXRBQjs = require('../../chunk-VTKKXRBQ.js');


var _chunkDE4A7PETjs = require('../../chunk-DE4A7PET.js');

// src/APL/dynamodb/dynamodb-apl.ts
var _api = require('@opentelemetry/api');

// src/APL/dynamodb/apl-db-model.ts
var _dynamodbtoolbox = require('dynamodb-toolbox');
var AplAccessPattern = class {
  getPK({ saleorApiUrl }) {
    return `${saleorApiUrl}`;
  }
  /*
   * APL is singleton, PK will scope to specific installation,
   * So full path will be like this:
   * PK: <saleorApiUrl>#<appId>
   * SK: APL
   */
  getSK() {
    return "APL";
  }
};
var AplEntrySchema = _dynamodbtoolbox.item.call(void 0, {
  PK: _dynamodbtoolbox.string.call(void 0, ).key(),
  SK: _dynamodbtoolbox.string.call(void 0, ).key(),
  token: _dynamodbtoolbox.string.call(void 0, ),
  saleorApiUrl: _dynamodbtoolbox.string.call(void 0, ),
  appId: _dynamodbtoolbox.string.call(void 0, ),
  jwks: _dynamodbtoolbox.string.call(void 0, ).optional()
});
var createAplEntity = (table) => new (0, _dynamodbtoolbox.Entity)({
  table,
  name: "APL",
  schema: AplEntrySchema,
  timestamps: {
    created: {
      name: "createdAt",
      savedAs: "createdAt"
    },
    modified: {
      name: "modifiedAt",
      savedAs: "modifiedAt"
    }
  }
});

// src/APL/dynamodb/dynamo-apl-repository.ts







var DynamoAPLRepository = class {
  constructor(deps) {
    this.access = new AplAccessPattern();
    this.aplEntity = deps.entity;
  }
  async getEntry(args) {
    const result = await this.aplEntity.build(_dynamodbtoolbox.GetItemCommand).key({
      PK: this.access.getPK({
        saleorApiUrl: args.saleorApiUrl
      }),
      SK: this.access.getSK()
    }).send();
    if (!result.Item) {
      return null;
    }
    const { saleorApiUrl, jwks, token, appId } = AplEntrySchema.build(_dynamodbtoolbox.Parser).parse(result.Item);
    return {
      saleorApiUrl,
      appId,
      jwks,
      token
    };
  }
  async setEntry({ authData }) {
    await this.aplEntity.build(_dynamodbtoolbox.PutItemCommand).item({
      PK: this.access.getPK({ saleorApiUrl: authData.saleorApiUrl }),
      SK: this.access.getSK(),
      token: authData.token,
      saleorApiUrl: authData.saleorApiUrl,
      appId: authData.appId,
      jwks: authData.jwks
    }).send();
    return void 0;
  }
  async deleteEntry(args) {
    await this.aplEntity.build(_dynamodbtoolbox.DeleteItemCommand).key({
      PK: this.access.getPK({
        saleorApiUrl: args.saleorApiUrl
      }),
      SK: this.access.getSK()
    }).send();
    return void 0;
  }
  async getAllEntries() {
    const scanEntriesResult = await this.aplEntity.table.build(_dynamodbtoolbox.ScanCommand).entities(this.aplEntity).options({
      // keep all the entries in memory - we should introduce pagination in the future
      maxPages: Infinity
    }).send();
    const possibleItems = _nullishCoalesce(scanEntriesResult.Items, () => ( []));
    if (possibleItems.length > 0) {
      return possibleItems.map((item2) => {
        const { appId, jwks, token, saleorApiUrl } = item2;
        return {
          saleorApiUrl,
          appId,
          jwks,
          token
        };
      });
    }
    return null;
  }
};

// src/APL/dynamodb/dynamodb-apl.ts
var DynamoAPL = class _DynamoAPL {
  constructor(deps) {
    this.tracer = _chunkVTKKXRBQjs.getOtelTracer.call(void 0, );
    this.debug = _chunkDE4A7PETjs.createDebug.call(void 0, "DynamoAPL");
    this.externalLogger = () => {
    };
    this.log = (message, level) => {
      this.debug(message);
      this.externalLogger(message, level);
    };
    this.repository = deps.repository;
    if (deps.externalLogger) {
      this.externalLogger = deps.externalLogger;
    }
  }
  static create(deps) {
    return new _DynamoAPL({
      repository: new DynamoAPLRepository({
        entity: createAplEntity(deps.table)
      })
    });
  }
  async get(saleorApiUrl) {
    this.log(`get called with saleorApiUrl: ${saleorApiUrl}`, "debug");
    return this.tracer.startActiveSpan("DynamoAPL.get", async (span) => {
      try {
        const getEntryResult = await this.repository.getEntry({
          saleorApiUrl
        });
        span.setStatus({
          code: _api.SpanStatusCode.OK
        }).end();
        this.log(`get successful for saleorApiUrl: ${saleorApiUrl}`, "debug");
        return _nullishCoalesce(getEntryResult, () => ( void 0));
      } catch (e) {
        span.setStatus({ code: _api.SpanStatusCode.ERROR }).end();
        this.log(
          `get error for saleorApiUrl: ${saleorApiUrl}, error: ${JSON.stringify(e)}`,
          "error"
        );
        throw new Error("GetAuthDataError: Failed to get APL entry", {
          cause: e
        });
      }
    });
  }
  async set(authData) {
    this.log(`set called with authData for saleorApiUrl: ${authData.saleorApiUrl}`, "debug");
    return this.tracer.startActiveSpan("DynamoAPL.set", async (span) => {
      try {
        await this.repository.setEntry({
          authData
        });
        span.setStatus({
          code: _api.SpanStatusCode.OK
        }).end();
        this.log(`set successful for saleorApiUrl: ${authData.saleorApiUrl}`, "debug");
      } catch (e) {
        span.setStatus({ code: _api.SpanStatusCode.ERROR }).end();
        this.log(
          `set error for saleorApiUrl: ${authData.saleorApiUrl}, error: ${JSON.stringify(e)}`,
          "error"
        );
        throw new Error("SetAuthDataError: Failed to set APL entry", {
          cause: e
        });
      }
    });
  }
  async delete(saleorApiUrl) {
    this.log(`delete called with saleorApiUrl: ${saleorApiUrl}`, "debug");
    return this.tracer.startActiveSpan("DynamoAPL.delete", async (span) => {
      try {
        await this.repository.deleteEntry({
          saleorApiUrl
        });
        span.setStatus({
          code: _api.SpanStatusCode.OK
        }).end();
        this.log(`delete successful for saleorApiUrl: ${saleorApiUrl}`, "debug");
      } catch (e) {
        span.setStatus({ code: _api.SpanStatusCode.ERROR }).end();
        this.log(
          `delete error for saleorApiUrl: ${saleorApiUrl}, error: ${JSON.stringify(e)}`,
          "error"
        );
        throw new Error("DeleteAuthDataError: Failed to set APL entry", {
          cause: e
        });
      }
    });
  }
  async getAll() {
    this.log("getAll called", "debug");
    return this.tracer.startActiveSpan("DynamoAPL.getAll", async (span) => {
      try {
        const getAllEntriesResult = await this.repository.getAllEntries();
        span.setStatus({
          code: _api.SpanStatusCode.OK
        }).end();
        this.log(`getAll successful, found ${_nullishCoalesce(_optionalChain([getAllEntriesResult, 'optionalAccess', _ => _.length]), () => ( 0))} entries`, "debug");
        return _nullishCoalesce(getAllEntriesResult, () => ( []));
      } catch (e) {
        span.setStatus({ code: _api.SpanStatusCode.ERROR }).end();
        this.log(`getAll error: ${JSON.stringify(e)}`, "error");
        throw new Error("GetAllAuthDataError: Failed to set APL entry", {
          cause: e
        });
      }
    });
  }
};


exports.DynamoAPL = DynamoAPL;