@aspan-corporation/ac-shared 1.2.25 → 1.2.27

package/lib/services/dynamoDB.d.ts

@@ -1,6 +1,6 @@
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { AssumeRoleCommandOutput } from "@aws-sdk/client-sts";
-import { DynamoDBDocumentClient, GetCommandInput, GetCommandOutput, PutCommandInput, PutCommandOutput, QueryCommandInput, QueryCommandOutput, UpdateCommandInput, UpdateCommandOutput, ScanCommandInput, ScanCommandOutput, BatchWriteCommandInput, BatchWriteCommandOutput } from "@aws-sdk/lib-dynamodb";
+import { DynamoDBDocumentClient, GetCommandInput, GetCommandOutput, PutCommandInput, PutCommandOutput, QueryCommandInput, QueryCommandOutput, UpdateCommandInput, UpdateCommandOutput, ScanCommandInput, ScanCommandOutput, BatchWriteCommandInput, BatchWriteCommandOutput, BatchGetCommandInput, BatchGetCommandOutput } from "@aws-sdk/lib-dynamodb";
 import { Logger } from "@aws-lambda-powertools/logger";
 export declare class DynamoDBService {
     logger: Logger;
@@ -19,6 +19,7 @@ export declare class DynamoDBService {
     checkIfItemExists(checkInput: Pick<GetCommandInput, "TableName" | "Key">): Promise<boolean>;
     scanCommand(scanCommandInput: ScanCommandInput): Promise<ScanCommandOutput>;
     batchWriteCommand(batchWriteCommandInput: BatchWriteCommandInput): Promise<BatchWriteCommandOutput>;
+    batchGetCommand(batchGetCommandInput: BatchGetCommandInput): Promise<BatchGetCommandOutput>;
 }
 export type { PutCommandOutput } from "@aws-sdk/lib-dynamodb";
 export type { BatchWriteCommandOutput } from "@aws-sdk/lib-dynamodb";
@@ -27,6 +28,8 @@ export type { QueryCommandOutput } from "@aws-sdk/lib-dynamodb";
 export type { GetCommandOutput } from "@aws-sdk/lib-dynamodb";
 export type { UpdateCommandOutput } from "@aws-sdk/lib-dynamodb";
 export type { BatchWriteCommandInput } from "@aws-sdk/lib-dynamodb";
+export type { BatchGetCommandInput } from "@aws-sdk/lib-dynamodb";
+export type { BatchGetCommandOutput } from "@aws-sdk/lib-dynamodb";
 export type { PutCommandInput } from "@aws-sdk/lib-dynamodb";
 export type { ScanCommandInput } from "@aws-sdk/lib-dynamodb";
 export type { QueryCommandInput } from "@aws-sdk/lib-dynamodb";

package/lib/services/dynamoDB.js

@@ -1,5 +1,5 @@
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand, ScanCommand, BatchWriteCommand } from "@aws-sdk/lib-dynamodb";
+import { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand, ScanCommand, BatchWriteCommand, BatchGetCommand } from "@aws-sdk/lib-dynamodb";
 import assert from "node:assert/strict";
 import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
 export class DynamoDBService {
@@ -42,4 +42,7 @@ export class DynamoDBService {
     async batchWriteCommand(batchWriteCommandInput) {
         return await this.client.send(new BatchWriteCommand(batchWriteCommandInput));
     }
+    async batchGetCommand(batchGetCommandInput) {
+        return await this.client.send(new BatchGetCommand(batchGetCommandInput));
+    }
 }

package/lib/services/s3.d.ts

@@ -22,6 +22,13 @@ export declare class S3Service {
     putObject(putObjectCommandInput: PutObjectCommandInput): Promise<PutObjectCommandOutput>;
     headObject(headObjectCommandInput: HeadObjectCommandInput): Promise<import("@aws-sdk/client-s3").HeadObjectCommandOutput>;
     checkIfObjectExists(headObjectCommandInput: HeadObjectCommandInput): Promise<boolean>;
+    checkIfObjectExistsAndNonEmpty(headObjectCommandInput: HeadObjectCommandInput): Promise<boolean>;
+    /**
+     * Returns true for both 404 (NotFound) and 403 responses.
+     * Some S3 bucket policies return 403 instead of 404 for missing keys
+     * to avoid revealing whether a key exists — treat both as "not found".
+     */
+    private isNotFound;
     deleteObject(deleteObjectCommandInput: DeleteObjectCommandInput): Promise<DeleteObjectCommandOutput>;
     deleteObjects(deleteObjectsCommandInput: DeleteObjectsCommandInput): Promise<DeleteObjectsCommandOutput>;
 }

package/lib/services/s3.js

@@ -75,12 +75,33 @@ export class S3Service {
             return true;
         }
         catch (error) {
-            if (error.name === "NotFound") {
+            if (this.isNotFound(error))
                 return false;
-            }
             throw error;
         }
     }
+    async checkIfObjectExistsAndNonEmpty(headObjectCommandInput) {
+        this.logger.debug("checkIfObjectExistsAndNonEmpty", { headObjectCommandInput });
+        try {
+            const head = await this.headObject(headObjectCommandInput);
+            return (head.ContentLength ?? 0) > 0;
+        }
+        catch (error) {
+            if (this.isNotFound(error))
+                return false;
+            throw error;
+        }
+    }
+    /**
+     * Returns true for both 404 (NotFound) and 403 responses.
+     * Some S3 bucket policies return 403 instead of 404 for missing keys
+     * to avoid revealing whether a key exists — treat both as "not found".
+     */
+    isNotFound(error) {
+        return (error.name === "NotFound" ||
+            error.$metadata?.httpStatusCode === 404 ||
+            error.$metadata?.httpStatusCode === 403);
+    }
     async deleteObject(deleteObjectCommandInput) {
         this.logger.debug("deleteObject", { deleteObjectCommandInput });
         return await this.client.send(new DeleteObjectCommand(deleteObjectCommandInput));

package/lib/services/ssm.d.ts

@@ -1,16 +1,18 @@
-import { GetParameterCommandInput, GetParameterCommandOutput, PutParameterCommandInput, PutParameterCommandOutput, SSMClient } from "@aws-sdk/client-ssm";
+import { GetParameterCommandInput, GetParameterCommandOutput, GetParametersByPathCommandInput, PutParameterCommandInput, PutParameterCommandOutput, SSMClient, type Parameter } from "@aws-sdk/client-ssm";
 import { AssumeRoleCommandOutput } from "@aws-sdk/client-sts";
 import { Logger } from "@aws-lambda-powertools/logger";
 export declare class SSMService {
-    logger: Logger;
+    logger?: Logger;
     client: SSMClient;
     constructor({ logger, client, assumeRoleCommandOutput, region }: {
-        logger: Logger;
+        logger?: Logger;
         client?: SSMClient;
         assumeRoleCommandOutput?: AssumeRoleCommandOutput;
         region?: string;
     });
     getParameter(params: GetParameterCommandInput): Promise<GetParameterCommandOutput>;
     putParameter(params: PutParameterCommandInput): Promise<PutParameterCommandOutput>;
+    /** Fetches all parameters under the given path, handling pagination automatically. */
+    getParametersByPath(params: GetParametersByPathCommandInput): Promise<Parameter[]>;
 }
-export type { GetParameterCommandInput, GetParameterCommandOutput, PutParameterCommandInput, PutParameterCommandOutput } from "@aws-sdk/client-ssm";
+export type { GetParameterCommandInput, GetParameterCommandOutput, GetParametersByPathCommandInput, Parameter, PutParameterCommandInput, PutParameterCommandOutput } from "@aws-sdk/client-ssm";

package/lib/services/ssm.js

@@ -1,4 +1,4 @@
-import { GetParameterCommand, PutParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+import { GetParameterCommand, GetParametersByPathCommand, PutParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
 import assert from "node:assert/strict";
 import { getObjectWithAssumeRoleCommandOutputAttribute } from "../utils/index.js";
 export class SSMService {
@@ -23,4 +23,15 @@ export class SSMService {
     async putParameter(params) {
         return await this.client.send(new PutParameterCommand(params));
     }
+    /** Fetches all parameters under the given path, handling pagination automatically. */
+    async getParametersByPath(params) {
+        const results = [];
+        let nextToken;
+        do {
+            const response = await this.client.send(new GetParametersByPathCommand({ ...params, NextToken: nextToken }));
+            results.push(...(response.Parameters ?? []));
+            nextToken = response.NextToken;
+        } while (nextToken);
+        return results;
+    }
 }

package/lib/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from "./normalizeErrorMessage.js";
 export * from "./thumbsKey.js";
 export * from "./helpers.js";
 export * from "./processMeta.js";
+export * from "./parseFolderDate.js";

package/lib/utils/index.js

@@ -7,3 +7,4 @@ export * from "./normalizeErrorMessage.js";
 export * from "./thumbsKey.js";
 export * from "./helpers.js";
 export * from "./processMeta.js";
+export * from "./parseFolderDate.js";

package/lib/utils/parseFolderDate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Parse a date prefix from a folder name.
+ *
+ * Recognises:
+ *   YYYYMMDD[non-digit...]   e.g. "20100321. Playground"
+ *   YYYY-MM-DD[...]          e.g. "2024-08-15 Vacation"
+ *   YYYY.MM.DD[...]          e.g. "2024.08.15 Vacation"
+ *
+ * Folder ids may be passed as the full path ("media/2024/08/15/foo/") or
+ * just the bare segment — we always extract the last non-empty segment first.
+ *
+ * Returns:
+ *   { year, month1, day, isoDate } where month1 is 1-indexed (1=Jan, 12=Dec).
+ *   null if the segment doesn't start with a recognisable date.
+ *
+ * The previous implementation in `processMeta.ts` had a bug rejecting January
+ * (it checked `month0 < 1`, where month0 was 0-indexed). It also constructed
+ * dates in local time, which differs by region. This implementation:
+ *   - validates 1 ≤ month ≤ 12 and 1 ≤ day ≤ 31 (so January is included)
+ *   - emits a UTC ISO timestamp via Date.UTC, eliminating timezone drift
+ *   - returns 1-indexed month for consumer convenience
+ */
+export type ParsedFolderDate = {
+    year: number;
+    month1: number;
+    day: number;
+    isoDate: string;
+};
+export declare const parseFolderDate: (id: string) => ParsedFolderDate | null;

package/lib/utils/parseFolderDate.js

@@ -0,0 +1,25 @@
+const COMPACT = /^(\d{4})(\d{2})(\d{2})/;
+const SEPARATED = /^(\d{4})[-.](\d{2})[-.](\d{2})/;
+export const parseFolderDate = (id) => {
+    // Last non-empty path segment
+    const segment = id.replace(/\/$/, "").split("/").pop() ?? "";
+    if (!segment)
+        return null;
+    const match = COMPACT.exec(segment) ?? SEPARATED.exec(segment);
+    if (!match)
+        return null;
+    const year = Number(match[1]);
+    const month1 = Number(match[2]);
+    const day = Number(match[3]);
+    if (Number.isNaN(year) || Number.isNaN(month1) || Number.isNaN(day))
+        return null;
+    if (year < 1900 || year > 2100)
+        return null;
+    if (month1 < 1 || month1 > 12)
+        return null;
+    if (day < 1 || day > 31)
+        return null;
+    // UTC midnight to avoid timezone drift in toISOString().
+    const isoDate = new Date(Date.UTC(year, month1 - 1, day)).toISOString();
+    return { year, month1, day, isoDate };
+};

package/lib/utils/processMeta.d.ts

@@ -21,4 +21,15 @@ type ExtractMetadataParams = {
  *
  */
 export declare const processMeta: ({ id, meta, metaTableName, placeIndexName, size, logger, locationService, dynamoDBService }: ExtractMetadataParams) => Promise<void>;
+/**
+ * Parent folder of an S3 key, used as the `folder` GSI partition key on the meta table.
+ *
+ *   "2024/08/15/photo.jpg" → "2024/08/15/"
+ *   "2024/08/15/"          → "2024/08/"
+ *   "2024/"                → "/"
+ *   ""                     → "/"
+ *
+ * Root sentinel "/" lets us partition top-level entries under a single PK.
+ */
+export declare const deriveFolder: (id: string) => string;
 export {};

package/lib/utils/processMeta.js

@@ -1,5 +1,5 @@
-import assert from "node:assert/strict";
 import { getKeyExtension } from "./thumbsKey.js";
+import { parseFolderDate } from "./parseFolderDate.js";
 /**
  * 1. read <id>
  * 2. if <id> doesn't exist then use PutCommand
@@ -85,9 +85,13 @@ export const processMeta = async ({ id, meta, metaTableName, placeIndexName, siz
         Key: {
             id
         },
-        UpdateExpression: "set tags = :tags",
+        UpdateExpression: "set tags = :tags, #folder = :folder",
+        ExpressionAttributeNames: {
+            "#folder": "folder"
+        },
         ExpressionAttributeValues: {
-            ":tags": reconciledTags
+            ":tags": reconciledTags,
+            ":folder": deriveFolder(id)
         },
         ReturnValues: "ALL_NEW"
     });
@@ -102,38 +106,45 @@ const reconcileTags = ({ oldTags = [], newTags = [] }, logger) => oldTags.reduce
         return [...acc, cur];
     }
 }, newTags);
-const SUBSTRING_ANSI_DATES_BEGIN_WITH = "20";
+/**
+ * Parent folder of an S3 key, used as the `folder` GSI partition key on the meta table.
+ *
+ *   "2024/08/15/photo.jpg" → "2024/08/15/"
+ *   "2024/08/15/"          → "2024/08/"
+ *   "2024/"                → "/"
+ *   ""                     → "/"
+ *
+ * Root sentinel "/" lets us partition top-level entries under a single PK.
+ */
+export const deriveFolder = (id) => {
+    if (!id)
+        return "/";
+    const trimmed = id.endsWith("/") ? id.slice(0, -1) : id;
+    const lastSlash = trimmed.lastIndexOf("/");
+    if (lastSlash < 0)
+        return "/";
+    return trimmed.slice(0, lastSlash + 1);
+};
+/**
+ * Derive date tags from the parent folder's name when it begins with a
+ * recognised date prefix (YYYYMMDD, YYYY-MM-DD, YYYY.MM.DD).
+ *
+ * Operates on the parent folder of the given key — for "media/20240815/photo.jpg"
+ * it parses "20240815". The previous implementation skipped January due to
+ * a 0-vs-1-indexed month bug; that has been fixed in `parseFolderDate`.
+ */
 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)
+    // Look at the parent folder, not the file itself.
+    const parent = key.endsWith("/") ? key : key.slice(0, key.lastIndexOf("/") + 1);
+    const parsed = parseFolderDate(parent);
+    if (!parsed)
         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()
-        }
+        { key: "dateCreated", value: parsed.isoDate },
+        { key: "yearCreated", value: String(parsed.year) },
+        { key: "dayCreated", value: String(parsed.day) },
+        { key: "monthCreated", value: String(parsed.month1) },
     ];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspan-corporation/ac-shared",
-  "version": "1.2.25",
+  "version": "1.2.27",
   "description": "",
   "keywords": [],
   "exports": {