@aspan-corporation/ac-shared 1.2.20 → 1.2.21

package/lib/lambda/index.d.ts

@@ -1,18 +1,18 @@
 import { IdempotencyConfig } from "@aws-lambda-powertools/idempotency";
+import { BasePersistenceLayer } from "@aws-lambda-powertools/idempotency/persistence";
 import { Logger } from "@aws-lambda-powertools/logger";
 import { Metrics } from "@aws-lambda-powertools/metrics";
 import { Tracer } from "@aws-lambda-powertools/tracer";
 import middy from "@middy/core";
-import type { Handler, SQSHandler } from "aws-lambda";
+import type { Context, Handler, SQSRecord } from "aws-lambda";
 import { DynamoDBService, LocationService, S3Service, SQSService, SSMService, STSService } from "../services/index.js";
-import { BasePersistenceLayer } from "@aws-lambda-powertools/idempotency/persistence";
 export declare const logger: Logger;
 export type { Logger } from "@aws-lambda-powertools/logger";
-export declare const tracer: Tracer;
+export { MetricUnit } from "@aws-lambda-powertools/metrics";
+export type { Metrics } from "@aws-lambda-powertools/metrics";
 export type { Tracer } from "@aws-lambda-powertools/tracer";
+export declare const tracer: Tracer;
 export declare const metrics: Metrics;
-export type { Metrics } from "@aws-lambda-powertools/metrics";
-export { MetricUnit } from "@aws-lambda-powertools/metrics";
 export declare const withMiddlewares: (handler: Handler) => middy.MiddyfiedHandler<any, any, Error, any>;
 export declare const getPersistenceStore: (tableName: string) => BasePersistenceLayer;
 export declare const getIdempotencyConfig: (eventKeyJmesPath: string) => IdempotencyConfig;
@@ -30,13 +30,12 @@ export type AcServices = {
     sourceS3Service?: S3Service;
     destinationS3Service?: S3Service;
 };
-declare module "aws-lambda" {
-    interface Context {
-        logger: Logger;
-        tracer: Tracer;
-        metrics: Metrics;
-        acServices?: AcServices;
-    }
-}
-export declare const getPartialResponseHandler: (handler: SQSHandler) => (event: any, context: any) => Promise<import("@aws-lambda-powertools/batch/types").PartialItemFailureResponse>;
+export type AcContext = Context & {
+    logger: Logger;
+    tracer: Tracer;
+    metrics: Metrics;
+    acServices?: AcServices;
+};
+type RecordHandler = (record: SQSRecord, context: AcContext) => Promise<void>;
+export declare const getPartialResponseHandler: (handler: RecordHandler) => (event: any, context: any) => Promise<import("@aws-lambda-powertools/batch/types").PartialItemFailureResponse>;
 export { makeIdempotent } from "@aws-lambda-powertools/idempotency";

package/lib/lambda/index.js

@@ -0,0 +1,56 @@
+import { BatchProcessor, EventType, processPartialResponse } from "@aws-lambda-powertools/batch";
+import { IdempotencyConfig } from "@aws-lambda-powertools/idempotency";
+import { DynamoDBPersistenceLayer } from "@aws-lambda-powertools/idempotency/dynamodb";
+import { Logger } from "@aws-lambda-powertools/logger";
+import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
+import { Metrics, MetricUnit } from "@aws-lambda-powertools/metrics";
+import { logMetrics } from "@aws-lambda-powertools/metrics/middleware";
+import { Tracer } from "@aws-lambda-powertools/tracer";
+import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
+import middy from "@middy/core";
+import { randomUUID } from "node:crypto";
+export const logger = new Logger();
+export { MetricUnit } from "@aws-lambda-powertools/metrics";
+export const tracer = new Tracer();
+export const metrics = new Metrics({ namespace: "aspan-corporation" });
+export const withMiddlewares = (handler) => middy(handler)
+    .use(injectLambdaContext(logger, { logEvent: true }))
+    .use(captureLambdaHandler(tracer))
+    .use(logMetrics(metrics, { captureColdStartMetric: true }))
+    .use({
+    before: async (request) => {
+        if (!logger.getCorrelationId()) {
+            logger.setCorrelationId(request.context.awsRequestId || randomUUID());
+        }
+        request.context.logger = logger;
+        request.context.tracer = tracer;
+        request.context.metrics = metrics;
+    }
+})
+    .use({
+    onError: async ({ error, context: { logger, metrics } }) => {
+        logger.error("Error handled by middleware", error);
+        metrics.addMetric("ErrorHandled", MetricUnit.Count, 1);
+    }
+});
+export const getPersistenceStore = (tableName) => {
+    return new DynamoDBPersistenceLayer({
+        tableName
+    });
+};
+export const getIdempotencyConfig = (eventKeyJmesPath) => {
+    return new IdempotencyConfig({
+        eventKeyJmesPath
+    });
+};
+export const getIdempotencyOptions = (tableName, path) => ({
+    persistenceStore: getPersistenceStore(tableName),
+    config: getIdempotencyConfig(path)
+});
+export const getPartialResponseHandler = (handler) => {
+    const processor = new BatchProcessor(EventType.SQS);
+    return async (event, context) => processPartialResponse(event, handler, processor, {
+        context
+    });
+};
+export { makeIdempotent } from "@aws-lambda-powertools/idempotency";

package/lib/services/cloudWatch.js

@@ -0,0 +1,30 @@
+import { CloudWatchLogsClient, DescribeLogStreamsCommand, PutLogEventsCommand } from "@aws-sdk/client-cloudwatch-logs";
+import assert from "node:assert/strict";
+import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
+export class CloudWatchService {
+    logger;
+    client;
+    constructor({ logger, client, assumeRoleCommandOutput, region }) {
+        this.logger = logger;
+        if (client) {
+            this.client = client;
+        }
+        else {
+            assert(region, "Region must be provided if client is not passed");
+            this.client = new CloudWatchLogsClient({
+                region,
+                ...getObjectWithAssumeRoleCommandOutputAttribute(assumeRoleCommandOutput)
+            });
+        }
+    }
+    async describeLogStreamsCommand(describeLogStreamsCommandInput) {
+        this.logger.debug("describeLogStreamsCommand", {
+            describeLogStreamsCommandInput
+        });
+        return await this.client.send(new DescribeLogStreamsCommand(describeLogStreamsCommandInput));
+    }
+    async putLogEventsCommand(putLogEventsCommandInput) {
+        this.logger.debug("putLogEventsCommand", { putLogEventsCommandInput });
+        return await this.client.send(new PutLogEventsCommand(putLogEventsCommandInput));
+    }
+}

package/lib/services/dynamoDB.js

@@ -0,0 +1,45 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand, ScanCommand, BatchWriteCommand } from "@aws-sdk/lib-dynamodb";
+import assert from "node:assert/strict";
+import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
+export class DynamoDBService {
+    logger;
+    client;
+    documentClient;
+    constructor({ logger, client, assumeRoleCommandOutput, region }) {
+        this.logger = logger;
+        if (client) {
+            this.client = client;
+        }
+        else {
+            assert(region, "Region must be provided if client is not passed");
+            this.client = new DynamoDBClient({
+                region,
+                ...getObjectWithAssumeRoleCommandOutputAttribute(assumeRoleCommandOutput)
+            });
+        }
+        this.documentClient = DynamoDBDocumentClient.from(this.client);
+    }
+    async getCommand(getCommandInput) {
+        return await this.documentClient.send(new GetCommand(getCommandInput));
+    }
+    async updateCommand(updateCommandInput) {
+        return await this.documentClient.send(new UpdateCommand(updateCommandInput));
+    }
+    async queryCommand(queryCommandInput) {
+        return await this.documentClient.send(new QueryCommand(queryCommandInput));
+    }
+    async putCommand(putCommandInput) {
+        return await this.documentClient.send(new PutCommand(putCommandInput));
+    }
+    async checkIfItemExists(checkInput) {
+        const result = await this.getCommand(checkInput);
+        return !!result.Item;
+    }
+    async scanCommand(scanCommandInput) {
+        return await this.client.send(new ScanCommand(scanCommandInput));
+    }
+    async batchWriteCommand(batchWriteCommandInput) {
+        return await this.client.send(new BatchWriteCommand(batchWriteCommandInput));
+    }
+}

package/lib/services/index.js

@@ -0,0 +1,7 @@
+export * from "./s3.js";
+export * from "./dynamoDB.js";
+export * from "./ssm.js";
+export * from "./sqs.js";
+export * from "./sts.js";
+export * from "./location.js";
+export * from "./cloudWatch.js";

package/lib/services/location.js

@@ -0,0 +1,23 @@
+import { LocationClient, SearchPlaceIndexForPositionCommand } from "@aws-sdk/client-location";
+import assert from "node:assert/strict";
+import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
+export class LocationService {
+    logger;
+    client;
+    constructor({ logger, client, assumeRoleCommandOutput, region }) {
+        this.logger = logger;
+        if (client) {
+            this.client = client;
+        }
+        else {
+            assert(region, "Region must be provided if client is not passed");
+            this.client = new LocationClient({
+                region,
+                ...getObjectWithAssumeRoleCommandOutputAttribute(assumeRoleCommandOutput)
+            });
+        }
+    }
+    async searchPlaceIndexForPositionCommand(searchPlaceIndexForPositionCommandInput) {
+        return await this.client.send(new SearchPlaceIndexForPositionCommand(searchPlaceIndexForPositionCommandInput));
+    }
+}

package/lib/services/s3.js

@@ -0,0 +1,92 @@
+import { DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import assert from "node:assert/strict";
+import { PassThrough } from "node:stream";
+import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+export class S3Service {
+    logger;
+    client;
+    constructor({ logger, client, assumeRoleCommandOutput, region }) {
+        this.logger = logger;
+        if (client) {
+            this.client = client;
+        }
+        else {
+            assert(region, "Region must be provided if client is not passed");
+            this.client = new S3Client({
+                region,
+                ...getObjectWithAssumeRoleCommandOutputAttribute(assumeRoleCommandOutput)
+            });
+        }
+    }
+    createS3UploadStream(putObjectCommandInput) {
+        this.logger.debug("upload stream started", { putObjectCommandInput });
+        const pass = new PassThrough();
+        const parallelUploads = new Upload({
+            client: this.client,
+            params: {
+                ...putObjectCommandInput,
+                Body: pass
+            }
+        });
+        const donePromise = parallelUploads
+            .done()
+            .then(() => this.logger.debug("upload stream finished"))
+            .catch((err) => {
+            this.logger.error("upload stream error", err);
+            pass.destroy(err);
+            throw err;
+        });
+        return { stream: pass, done: donePromise };
+    }
+    async createS3DownloadStream(getObjectCommandInput) {
+        this.logger.debug("download stream started", { getObjectCommandInput });
+        const item = await this.client.send(new GetObjectCommand(getObjectCommandInput));
+        this.logger.debug("download stream finished");
+        return item.Body;
+    }
+    async listObjectsV2(listObjectsV2CommandInput) {
+        this.logger.debug("listObjectsV2", { listObjectsV2CommandInput });
+        return await this.client.send(new ListObjectsV2Command(listObjectsV2CommandInput));
+    }
+    async getObject(getObjectCommandInput) {
+        this.logger.debug("getObject", { getObjectCommandInput });
+        const stream = await this.createS3DownloadStream(getObjectCommandInput);
+        return Buffer.from(await stream.transformToByteArray());
+    }
+    async getSignedUrl(getObjectCommandInput) {
+        this.logger.debug("getSignedUrl", { getObjectCommandInput });
+        const signedUrl = await getSignedUrl(this.client, new GetObjectCommand(getObjectCommandInput), { expiresIn: 3600 });
+        return signedUrl;
+    }
+    async putObject(putObjectCommandInput) {
+        this.logger.debug("putObject", { putObjectCommandInput });
+        return await this.client.send(new PutObjectCommand(putObjectCommandInput));
+    }
+    async headObject(headObjectCommandInput) {
+        this.logger.debug("headObject", { headObjectCommandInput });
+        return await this.client.send(new HeadObjectCommand(headObjectCommandInput));
+    }
+    async checkIfObjectExists(headObjectCommandInput) {
+        this.logger.debug("checkIfObjectExists", { headObjectCommandInput });
+        try {
+            await this.headObject(headObjectCommandInput);
+            return true;
+        }
+        catch (error) {
+            if (error.name === "NotFound") {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async deleteObject(deleteObjectCommandInput) {
+        this.logger.debug("deleteObject", { deleteObjectCommandInput });
+        return await this.client.send(new DeleteObjectCommand(deleteObjectCommandInput));
+    }
+    async deleteObjects(deleteObjectsCommandInput) {
+        this.logger.debug("deleteObjects", { deleteObjectsCommandInput });
+        return await this.client.send(new DeleteObjectsCommand(deleteObjectsCommandInput));
+    }
+}

package/lib/services/sqs.js

@@ -0,0 +1,32 @@
+import { DeleteMessageCommand, ReceiveMessageCommand, SQSClient, SendMessageBatchCommand, SendMessageCommand } from "@aws-sdk/client-sqs";
+import assert from "node:assert/strict";
+import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
+export class SQSService {
+    logger;
+    client;
+    constructor({ logger, client, assumeRoleCommandOutput, region }) {
+        this.logger = logger;
+        if (client) {
+            this.client = client;
+        }
+        else {
+            assert(region, "Region must be provided if client is not passed");
+            this.client = new SQSClient({
+                region,
+                ...getObjectWithAssumeRoleCommandOutputAttribute(assumeRoleCommandOutput)
+            });
+        }
+    }
+    async sendMessage(params) {
+        return await this.client.send(new SendMessageCommand(params));
+    }
+    async sendMessageBatch(params) {
+        return await this.client.send(new SendMessageBatchCommand(params));
+    }
+    async receiveMessage(params) {
+        return await this.client.send(new ReceiveMessageCommand(params));
+    }
+    async deleteMessage(params) {
+        return await this.client.send(new DeleteMessageCommand(params));
+    }
+}

package/lib/services/ssm.js

@@ -0,0 +1,26 @@
+import { GetParameterCommand, PutParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+import assert from "node:assert/strict";
+import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
+export class SSMService {
+    logger;
+    client;
+    constructor({ logger, client, assumeRoleCommandOutput, region }) {
+        this.logger = logger;
+        if (client) {
+            this.client = client;
+        }
+        else {
+            assert(region, "Region must be provided if client is not passed");
+            this.client = new SSMClient({
+                region,
+                ...getObjectWithAssumeRoleCommandOutputAttribute(assumeRoleCommandOutput)
+            });
+        }
+    }
+    async getParameter(params) {
+        return await this.client.send(new GetParameterCommand(params));
+    }
+    async putParameter(params) {
+        return await this.client.send(new PutParameterCommand(params));
+    }
+}

package/lib/services/sts.js

@@ -0,0 +1,33 @@
+import { Logger } from "@aws-lambda-powertools/logger";
+import { AssumeRoleCommand, GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
+import assert from "node:assert/strict";
+export class STSService {
+    logger;
+    client;
+    constructor({ logger, region, client }) {
+        if (logger) {
+            this.logger = logger;
+        }
+        else {
+            this.logger = new Logger();
+            this.logger.appendKeys({ scope: "STSService" });
+        }
+        if (client) {
+            this.client = client;
+        }
+        else {
+            assert(region, "Region must be provided if client is not passed");
+            this.client = new STSClient({
+                region
+            });
+        }
+    }
+    async getCallerIdentity() {
+        this.logger.debug("getCallerIdentity");
+        return await this.client.send(new GetCallerIdentityCommand({}));
+    }
+    async assumeRole(assumeRoleCommandInput) {
+        this.logger.debug("assumeRole", { assumeRoleCommandInput });
+        return await this.client.send(new AssumeRoleCommand(assumeRoleCommandInput));
+    }
+}

package/lib/utils/helpers.js

@@ -0,0 +1,10 @@
+export const getObjectWithAssumeRoleCommandOutputAttribute = (assumeRoleCommandOutput) => assumeRoleCommandOutput
+    ? {
+        credentials: {
+            accessKeyId: assumeRoleCommandOutput?.Credentials?.AccessKeyId,
+            secretAccessKey: assumeRoleCommandOutput?.Credentials?.SecretAccessKey,
+            sessionToken: assumeRoleCommandOutput?.Credentials?.SessionToken
+        }
+    }
+    : {};
+export const getObjectWithStackAttribute = (error) => error && error instanceof Error ? { stack: error.stack } : {};

package/lib/utils/index.js

@@ -0,0 +1,9 @@
+import assert from "node:assert/strict";
+export const assertEnvVar = (envVar) => {
+    assert(process.env[envVar], `${envVar} is not set`);
+    return process.env[envVar];
+};
+export * from "./normalizeErrorMessage.js";
+export * from "./thumbsKey.js";
+export * from "./helpers.js";
+export * from "./processMeta.js";

package/lib/utils/normalizeErrorMessage.js

@@ -0,0 +1,14 @@
+export const normalizeErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    else if (typeof error === "string") {
+        return error;
+    }
+    else if (typeof error === "object" && error !== null) {
+        return JSON.stringify(error);
+    }
+    else {
+        return String(error);
+    }
+};

package/lib/utils/processMeta.js

@@ -0,0 +1,135 @@
+import assert from "node:assert/strict";
+import { getKeyExtension } from "./thumbsKey.js";
+/**
+ * 1. read <id>
+ * 2. if <id> doesn't exist then use PutCommand
+ * 3. if it does exist then match new tags and old tags
+ * 4. add all old tags that are not present in new tags,
+ *
+ */
+export const processMeta = async ({ id, meta, metaTableName, size, logger, locationService, dynamoDBService }) => {
+    // expand location data
+    const latitude = Number(meta.find((tag) => tag.key === "latitude")?.value);
+    const longitude = Number(meta.find((tag) => tag.key === "longitude")?.value);
+    let geoPositionResult;
+    if (!Number.isNaN(longitude) && !Number.isNaN(latitude)) {
+        try {
+            const res = await locationService.searchPlaceIndexForPositionCommand({
+                IndexName: "TauPlaceIndex",
+                Position: [longitude, latitude]
+            });
+            if (res?.Results && res?.Results?.length > 0) {
+                geoPositionResult = res?.Results[0];
+            }
+            else {
+                throw Error("Can not resolve geo data");
+            }
+        }
+        catch (error) {
+            logger.error("Error fetching geo data", {
+                message: error instanceof Error ? error.message : ""
+            });
+        }
+    }
+    const newTags = [
+        ...meta,
+        ...(meta.find((tag) => tag.key === "dateCreated")
+            ? []
+            : extractMetaFromKey(id)),
+        { key: "extension", value: getKeyExtension(id) },
+        { key: "size", value: String(size) },
+        { key: "sizeMb", value: String(Math.round(size / 1024 ** 2)) },
+        ...(geoPositionResult?.Place?.Label
+            ? [{ key: "label", value: geoPositionResult?.Place?.Label }]
+            : []),
+        ...(geoPositionResult?.Place?.Country
+            ? [{ key: "country", value: geoPositionResult?.Place?.Country }]
+            : []),
+        ...(geoPositionResult?.Place?.Region
+            ? [{ key: "region", value: geoPositionResult?.Place?.Region }]
+            : []),
+        ...(geoPositionResult?.Place?.SubRegion
+            ? [{ key: "subRegion", value: geoPositionResult?.Place?.SubRegion }]
+            : []),
+        ...(geoPositionResult?.Place?.Municipality
+            ? [{ key: "municipality", value: geoPositionResult?.Place?.Municipality }]
+            : []),
+        ...(geoPositionResult?.Place?.Neighborhood
+            ? [{ key: "neighborhood", value: geoPositionResult?.Place?.Neighborhood }]
+            : []),
+        ...(geoPositionResult?.Place?.PostalCode
+            ? [{ key: "postalCode", value: geoPositionResult?.Place?.PostalCode }]
+            : [])
+    ].map((tag) => ({
+        key: "ac:tau:" + tag.key,
+        value: tag.value
+    }));
+    logger.debug("metaData", { newTags });
+    logger.debug("trying to read existing metadata");
+    const getResponse = await dynamoDBService.getCommand({
+        TableName: metaTableName,
+        Key: {
+            id
+        }
+    });
+    const oldTags = getResponse.Item?.tags;
+    logger.debug("existing tags", { getResponse });
+    const reconciledTags = reconcileTags({ newTags, oldTags }, logger);
+    logger.debug("result", { reconciledTags });
+    const updateResponse = await dynamoDBService.updateCommand({
+        TableName: metaTableName,
+        Key: {
+            id
+        },
+        UpdateExpression: "set tags = :tags",
+        ExpressionAttributeValues: {
+            ":tags": reconciledTags
+        },
+        ReturnValues: "ALL_NEW"
+    });
+    logger.debug("sent UpdateCommand", { updateResponse });
+};
+const reconcileTags = ({ oldTags = [], newTags = [] }, logger) => oldTags.reduce((acc, cur) => {
+    if (acc.find((element) => element.key === cur.key)) {
+        return acc;
+    }
+    else {
+        logger.debug("added", cur);
+        return [...acc, cur];
+    }
+}, newTags);
+const SUBSTRING_ANSI_DATES_BEGIN_WITH = "20";
+const extractMetaFromKey = (key) => {
+    if (!key)
+        return [];
+    let firstToken = undefined;
+    try {
+        const folder = key.split("/").at(-2);
+        assert(typeof folder === "string");
+        firstToken = folder.split(".")[0];
+    }
+    catch (error) { }
+    if (firstToken === undefined ||
+        firstToken.length !== 8 ||
+        !firstToken.startsWith(SUBSTRING_ANSI_DATES_BEGIN_WITH))
+        return [];
+    const year = Number(firstToken.substring(0, 4));
+    const month = Number(firstToken.substring(4, 6)) - 1;
+    const day = Number(firstToken.substring(6));
+    if (isNaN(year) || isNaN(month) || isNaN(day))
+        return [];
+    // mon starts from 0
+    // day starts from 1
+    if (year < 2000 || month < 1 || month > 11 || day < 1 || day > 31)
+        return [];
+    const dateCreatedBin = new Date(year, month, day);
+    return [
+        { key: "dateCreated", value: dateCreatedBin.toISOString() },
+        { key: "yearCreated", value: dateCreatedBin.getFullYear().toString() },
+        { key: "dayCreated", value: dateCreatedBin.getDate().toString() },
+        {
+            key: "monthCreated",
+            value: (dateCreatedBin.getMonth() + 1).toString()
+        }
+    ];
+};

package/lib/utils/thumbsKey.d.ts

@@ -1,13 +1,17 @@
-export declare const JPEG_EXTENSION = "jpeg";
-export declare const JPG_EXTENSION = "jpg";
-export declare const HEIC_EXTENSION = "heic";
-export declare const MOV_EXTENSION = "mov";
-export declare const THUMBS_EXTENSION = "jpg";
-export declare const ENCODED_VIDEO_EXTENSION = "mp4";
+export declare const EXTENSION_JPEG = "jpeg";
+export declare const EXTENSION_JPG = "jpg";
+export declare const EXTENSION_WEBP = "webp";
+export declare const EXTENSION_HEIC = "heic";
+export declare const EXTENSION_MOV = "mov";
+export declare const EXTENSION_THUMBS = "webp";
+export declare const EXTENSION_ENCODED_VIDEO = "mp4";
 export declare const ALLOWED_EXTENSIONS: string[];
 export declare const ALLOWED_VIDEO_EXTENSIONS: string[];
-export declare const THUMBNAIL_RESOLUTIONS: number[][];
-export declare const getThumbsKey: ({ key, width, height }: {
+export declare const DIM_THUMBNAIL_WIDTH = 320;
+export declare const DIM_THUMBNAIL_HEIGHT = 320;
+export declare const DIM_DETAIL_WIDTH = 1180;
+export declare const DIM_DETAIL_HEIGHT = 820;
+export declare const getThumbnailKey: ({ key, width, height }: {
     key: string;
     width: number;
     height: number;

package/lib/utils/thumbsKey.js

@@ -0,0 +1,42 @@
+import { extname, basename, dirname } from "node:path";
+export const EXTENSION_JPEG = "jpeg";
+export const EXTENSION_JPG = "jpg";
+export const EXTENSION_WEBP = "webp";
+export const EXTENSION_HEIC = "heic";
+export const EXTENSION_MOV = "mov";
+export const EXTENSION_THUMBS = EXTENSION_WEBP;
+export const EXTENSION_ENCODED_VIDEO = "mp4";
+export const ALLOWED_EXTENSIONS = [
+    EXTENSION_JPEG,
+    EXTENSION_JPG,
+    EXTENSION_HEIC
+];
+export const ALLOWED_VIDEO_EXTENSIONS = [EXTENSION_MOV];
+export const DIM_THUMBNAIL_WIDTH = 320;
+export const DIM_THUMBNAIL_HEIGHT = 320;
+export const DIM_DETAIL_WIDTH = 1180;
+export const DIM_DETAIL_HEIGHT = 820;
+const getPathNameWithoutExt = (key) => {
+    return dirname(key) + "/" + basename(key, extname(key));
+};
+export const getThumbnailKey = ({ key, width, height }) => {
+    return (getPathNameWithoutExt(key) +
+        "." +
+        width +
+        "x" +
+        height +
+        "." +
+        EXTENSION_THUMBS);
+};
+export const getEncodedVideoKey = ({ key }) => {
+    return getPathNameWithoutExt(key) + "." + EXTENSION_ENCODED_VIDEO;
+};
+export const getKeyExtension = (key) => extname(key).slice(1).toLowerCase();
+export const isAllowedExtension = (key) => {
+    const ext = getKeyExtension(key);
+    return ALLOWED_EXTENSIONS.includes(ext);
+};
+export const isAllowedVideoExtension = (key) => {
+    const ext = getKeyExtension(key);
+    return ALLOWED_VIDEO_EXTENSIONS.includes(ext);
+};