@projectdochelp/s3te 1.0.0

package/packages/aws-adapter/src/template.mjs

@@ -0,0 +1,578 @@
+import {
+  buildEnvironmentRuntimeConfig
+} from "../../core/src/index.mjs";
+
+function cfName(...parts) {
+  return parts.join("");
+}
+
+function sanitizeLogicalId(value) {
+  return value.replace(/[^A-Za-z0-9]/g, "");
+}
+
+function websiteEndpoint(bucketNameExpression) {
+  return {
+    "Fn::Join": [
+      "",
+      [
+        bucketNameExpression,
+        ".s3-website-",
+        { Ref: "AWS::Region" },
+        ".amazonaws.com"
+      ]
+    ]
+  };
+}
+
+function handlerPath(name) {
+  return `packages/aws-adapter/src/runtime/${name}.handler`;
+}
+
+function lambdaCode(keyParameter) {
+  return {
+    S3Bucket: { Ref: "ArtifactBucket" },
+    S3Key: { Ref: keyParameter }
+  };
+}
+
+function lambdaRuntimeProperties(runtimeConfig, roleRef, name, keyParameter, handlerName, extra = {}) {
+  return {
+    Type: "AWS::Lambda::Function",
+    Properties: {
+      FunctionName: name,
+      Role: { "Fn::GetAtt": [roleRef, "Arn"] },
+      Runtime: runtimeConfig.lambda.runtime,
+      Handler: handlerPath(handlerName),
+      Architectures: [runtimeConfig.lambda.architecture],
+      Code: lambdaCode(keyParameter),
+      ...extra
+    }
+  };
+}
+
+function createExecutionRole(roleName) {
+  return {
+    Type: "AWS::IAM::Role",
+    Properties: {
+      RoleName: roleName,
+      AssumeRolePolicyDocument: {
+        Version: "2012-10-17",
+        Statement: [
+          {
+            Effect: "Allow",
+            Principal: {
+              Service: ["lambda.amazonaws.com"]
+            },
+            Action: ["sts:AssumeRole"]
+          }
+        ]
+      },
+      ManagedPolicyArns: [
+        "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+      ],
+      Policies: [
+        {
+          PolicyName: `${roleName}_access`,
+          PolicyDocument: {
+            Version: "2012-10-17",
+            Statement: [
+              {
+                Effect: "Allow",
+                Action: [
+                  "ssm:GetParameter",
+                  "ssm:PutParameter",
+                  "s3:GetObject",
+                  "s3:PutObject",
+                  "s3:DeleteObject",
+                  "s3:ListBucket",
+                  "dynamodb:BatchWriteItem",
+                  "dynamodb:DeleteItem",
+                  "dynamodb:GetItem",
+                  "dynamodb:PutItem",
+                  "dynamodb:Query",
+                  "dynamodb:Scan",
+                  "dynamodb:UpdateItem",
+                  "lambda:InvokeFunction",
+                  "states:StartExecution",
+                  "cloudfront:CreateInvalidation"
+                ],
+                Resource: "*"
+              }
+            ]
+          }
+        }
+      ]
+    }
+  };
+}
+
+export function buildCloudFormationTemplate({ config, environment, features = [] }) {
+  const runtimeConfig = buildEnvironmentRuntimeConfig(config, environment);
+  const resources = {};
+  const outputs = {};
+  const featureSet = new Set(features);
+
+  const functionNames = {
+    sourceDispatcher: `${runtimeConfig.stackPrefix}_s3te_source_dispatcher`,
+    renderWorker: `${runtimeConfig.stackPrefix}_s3te_render_worker`,
+    invalidationScheduler: `${runtimeConfig.stackPrefix}_s3te_invalidation_scheduler`,
+    invalidationExecutor: `${runtimeConfig.stackPrefix}_s3te_invalidation_executor`,
+    contentMirror: `${runtimeConfig.stackPrefix}_s3te_content_mirror`
+  };
+
+  const parameters = {
+    ArtifactBucket: {
+      Type: "String"
+    },
+    SourceDispatcherArtifactKey: {
+      Type: "String"
+    },
+    RenderWorkerArtifactKey: {
+      Type: "String"
+    },
+    InvalidationSchedulerArtifactKey: {
+      Type: "String"
+    },
+    InvalidationExecutorArtifactKey: {
+      Type: "String"
+    },
+    ContentMirrorArtifactKey: {
+      Type: "String",
+      Default: ""
+    },
+    RuntimeManifestValue: {
+      Type: "String",
+      Default: "{}"
+    },
+    WebinySourceTableStreamArn: {
+      Type: "String",
+      Default: ""
+    }
+  };
+
+  resources.ExecutionRole = createExecutionRole(`${runtimeConfig.stackPrefix}_s3te_lambda_runtime`);
+
+  resources.DependencyTable = {
+    Type: "AWS::DynamoDB::Table",
+    Properties: {
+      TableName: runtimeConfig.tables.dependency,
+      BillingMode: "PAY_PER_REQUEST",
+      AttributeDefinitions: [
+        { AttributeName: "sourceId", AttributeType: "S" },
+        { AttributeName: "dependencyKey", AttributeType: "S" }
+      ],
+      KeySchema: [
+        { AttributeName: "sourceId", KeyType: "HASH" },
+        { AttributeName: "dependencyKey", KeyType: "RANGE" }
+      ],
+      GlobalSecondaryIndexes: [
+        {
+          IndexName: "dependencyKey-index",
+          KeySchema: [
+            { AttributeName: "dependencyKey", KeyType: "HASH" },
+            { AttributeName: "sourceId", KeyType: "RANGE" }
+          ],
+          Projection: { ProjectionType: "ALL" }
+        }
+      ]
+    }
+  };
+
+  resources.ContentTable = {
+    Type: "AWS::DynamoDB::Table",
+    Properties: {
+      TableName: runtimeConfig.tables.content,
+      BillingMode: "PAY_PER_REQUEST",
+      AttributeDefinitions: [
+        { AttributeName: "id", AttributeType: "S" },
+        { AttributeName: "contentId", AttributeType: "S" }
+      ],
+      KeySchema: [
+        { AttributeName: "id", KeyType: "HASH" }
+      ],
+      GlobalSecondaryIndexes: [
+        {
+          IndexName: config.aws.contentStore.contentIdIndexName,
+          KeySchema: [
+            { AttributeName: "contentId", KeyType: "HASH" }
+          ],
+          Projection: { ProjectionType: "ALL" }
+        }
+      ]
+    }
+  };
+
+  resources.InvalidationTable = {
+    Type: "AWS::DynamoDB::Table",
+    Properties: {
+      TableName: runtimeConfig.tables.invalidation,
+      BillingMode: "PAY_PER_REQUEST",
+      AttributeDefinitions: [
+        { AttributeName: "distributionId", AttributeType: "S" },
+        { AttributeName: "requestId", AttributeType: "S" }
+      ],
+      KeySchema: [
+        { AttributeName: "distributionId", KeyType: "HASH" },
+        { AttributeName: "requestId", KeyType: "RANGE" }
+      ]
+    }
+  };
+
+  resources.RuntimeManifestParameter = {
+    Type: "AWS::SSM::Parameter",
+    Properties: {
+      Name: runtimeConfig.runtimeParameterName,
+      Type: "String",
+      Tier: "Advanced",
+      Value: { Ref: "RuntimeManifestValue" }
+    }
+  };
+
+  resources.InvalidationExecutor = lambdaRuntimeProperties(
+    runtimeConfig,
+    "ExecutionRole",
+    functionNames.invalidationExecutor,
+    "InvalidationExecutorArtifactKey",
+    "invalidation-executor",
+    {
+      Timeout: 300,
+      Environment: {
+        Variables: {
+          S3TE_ENVIRONMENT: environment,
+          S3TE_INVALIDATION_TABLE: runtimeConfig.tables.invalidation
+        }
+      }
+    }
+  );
+
+  resources.InvalidationStateMachine = {
+    Type: "AWS::StepFunctions::StateMachine",
+    Properties: {
+      StateMachineName: `${runtimeConfig.stackPrefix}_s3te_invalidation`,
+      RoleArn: { "Fn::GetAtt": ["ExecutionRole", "Arn"] },
+      DefinitionString: JSON.stringify({
+        Comment: "S3TE invalidation debounce state machine",
+        StartAt: "Wait",
+        States: {
+          Wait: {
+            Type: "Wait",
+            Seconds: config.aws.invalidationStore.debounceSeconds,
+            Next: "RunExecutor"
+          },
+          RunExecutor: {
+            Type: "Task",
+            Resource: "arn:aws:states:::lambda:invoke",
+            Parameters: {
+              FunctionName: "${InvalidationExecutorArn}",
+              "Payload.$": "$"
+            },
+            End: true
+          }
+        }
+      }),
+      DefinitionSubstitutions: {
+        InvalidationExecutorArn: { "Fn::GetAtt": ["InvalidationExecutor", "Arn"] }
+      }
+    }
+  };
+
+  resources.InvalidationScheduler = lambdaRuntimeProperties(
+    runtimeConfig,
+    "ExecutionRole",
+    functionNames.invalidationScheduler,
+    "InvalidationSchedulerArtifactKey",
+    "invalidation-scheduler",
+    {
+      Timeout: 300,
+      Environment: {
+        Variables: {
+          S3TE_ENVIRONMENT: environment,
+          S3TE_INVALIDATION_TABLE: runtimeConfig.tables.invalidation,
+          S3TE_DEBOUNCE_SECONDS: String(config.aws.invalidationStore.debounceSeconds),
+          S3TE_INVALIDATION_STATE_MACHINE_ARN: { Ref: "InvalidationStateMachine" }
+        }
+      }
+    }
+  );
+
+  resources.RenderWorker = lambdaRuntimeProperties(
+    runtimeConfig,
+    "ExecutionRole",
+    functionNames.renderWorker,
+    "RenderWorkerArtifactKey",
+    "render-worker",
+    {
+      Timeout: 900,
+      MemorySize: 1024,
+      Environment: {
+        Variables: {
+          S3TE_ENVIRONMENT: environment,
+          S3TE_RUNTIME_PARAMETER: runtimeConfig.runtimeParameterName,
+          S3TE_DEPENDENCY_TABLE: runtimeConfig.tables.dependency,
+          S3TE_CONTENT_TABLE: runtimeConfig.tables.content,
+          S3TE_INVALIDATION_SCHEDULER_NAME: functionNames.invalidationScheduler
+        }
+      }
+    }
+  );
+
+  resources.SourceDispatcher = lambdaRuntimeProperties(
+    runtimeConfig,
+    "ExecutionRole",
+    functionNames.sourceDispatcher,
+    "SourceDispatcherArtifactKey",
+    "source-dispatcher",
+    {
+      Timeout: 300,
+      MemorySize: 512,
+      Environment: {
+        Variables: {
+          S3TE_ENVIRONMENT: environment,
+          S3TE_RUNTIME_PARAMETER: runtimeConfig.runtimeParameterName,
+          S3TE_RENDER_WORKER_NAME: functionNames.renderWorker,
+          S3TE_RENDER_EXTENSIONS: runtimeConfig.rendering.renderExtensions.join(",")
+        }
+      }
+    }
+  );
+
+  if (featureSet.has("webiny") && runtimeConfig.integrations.webiny.enabled) {
+    resources.ContentMirror = lambdaRuntimeProperties(
+      runtimeConfig,
+      "ExecutionRole",
+      functionNames.contentMirror,
+      "ContentMirrorArtifactKey",
+      "content-mirror",
+      {
+        Timeout: 300,
+        MemorySize: 512,
+        Environment: {
+          Variables: {
+            S3TE_ENVIRONMENT: environment,
+            S3TE_CONTENT_TABLE: runtimeConfig.tables.content,
+            S3TE_RELEVANT_MODELS: runtimeConfig.integrations.webiny.relevantModels.join(","),
+            S3TE_WEBINY_TENANT: runtimeConfig.integrations.webiny.tenant ?? "",
+            S3TE_RENDER_WORKER_NAME: functionNames.renderWorker
+          }
+        }
+      }
+    );
+
+    resources.ContentMirrorEventSourceMapping = {
+      Type: "AWS::Lambda::EventSourceMapping",
+      Properties: {
+        BatchSize: 10,
+        StartingPosition: "LATEST",
+        EventSourceArn: { Ref: "WebinySourceTableStreamArn" },
+        FunctionName: { Ref: "ContentMirror" }
+      }
+    };
+  }
+
+  outputs.StackName = { Value: runtimeConfig.stackName };
+  outputs.RuntimeManifestParameterName = {
+    Value: runtimeConfig.runtimeParameterName
+  };
+  outputs.DependencyTableName = { Value: runtimeConfig.tables.dependency };
+  outputs.ContentTableName = { Value: runtimeConfig.tables.content };
+  outputs.InvalidationTableName = { Value: runtimeConfig.tables.invalidation };
+  outputs.SourceDispatcherFunctionName = { Value: functionNames.sourceDispatcher };
+  outputs.RenderWorkerFunctionName = { Value: functionNames.renderWorker };
+  outputs.InvalidationSchedulerFunctionName = { Value: functionNames.invalidationScheduler };
+  outputs.InvalidationExecutorFunctionName = { Value: functionNames.invalidationExecutor };
+
+  if (resources.ContentMirror) {
+    outputs.ContentMirrorFunctionName = { Value: functionNames.contentMirror };
+  }
+
+  for (const [variantName, variantConfig] of Object.entries(runtimeConfig.variants)) {
+    const codeBucketLogicalId = cfName(sanitizeLogicalId(variantName), "CodeBucket");
+    resources[codeBucketLogicalId] = {
+      Type: "AWS::S3::Bucket",
+      DependsOn: ["SourceDispatcherPermission"],
+      Properties: {
+        BucketName: variantConfig.codeBucket,
+        NotificationConfiguration: {
+          LambdaConfigurations: [
+            {
+              Event: "s3:ObjectCreated:*",
+              Function: { "Fn::GetAtt": ["SourceDispatcher", "Arn"] }
+            },
+            {
+              Event: "s3:ObjectRemoved:*",
+              Function: { "Fn::GetAtt": ["SourceDispatcher", "Arn"] }
+            }
+          ]
+        }
+      }
+    };
+    outputs[`${codeBucketLogicalId}Name`] = { Value: { Ref: codeBucketLogicalId } };
+
+    for (const [languageCode, languageConfig] of Object.entries(variantConfig.languages)) {
+      const suffix = sanitizeLogicalId(`${variantName}${languageCode}`);
+      const outputBucketLogicalId = `${suffix}OutputBucket`;
+      const distributionLogicalId = `${suffix}Distribution`;
+      const bucketPolicyLogicalId = `${suffix}OutputBucketPolicy`;
+      const websiteOriginId = `${suffix}Origin`;
+
+      resources[outputBucketLogicalId] = {
+        Type: "AWS::S3::Bucket",
+        Properties: {
+          BucketName: languageConfig.targetBucket,
+          WebsiteConfiguration: {
+            IndexDocument: variantConfig.routing.indexDocument,
+            ErrorDocument: variantConfig.routing.notFoundDocument
+          },
+          PublicAccessBlockConfiguration: {
+            BlockPublicAcls: false,
+            BlockPublicPolicy: false,
+            IgnorePublicAcls: false,
+            RestrictPublicBuckets: false
+          }
+        }
+      };
+
+      resources[bucketPolicyLogicalId] = {
+        Type: "AWS::S3::BucketPolicy",
+        Properties: {
+          Bucket: { Ref: outputBucketLogicalId },
+          PolicyDocument: {
+            Version: "2012-10-17",
+            Statement: [
+              {
+                Effect: "Allow",
+                Principal: "*",
+                Action: ["s3:GetObject"],
+                Resource: {
+                  "Fn::Join": [
+                    "",
+                    ["arn:aws:s3:::", { Ref: outputBucketLogicalId }, "/*"]
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      };
+
+      resources[distributionLogicalId] = {
+        Type: "AWS::CloudFront::Distribution",
+        Properties: {
+          DistributionConfig: {
+            Enabled: true,
+            Aliases: languageConfig.cloudFrontAliases,
+            DefaultRootObject: variantConfig.routing.indexDocument,
+            HttpVersion: "http2",
+            IPV6Enabled: true,
+            Origins: [
+              {
+                Id: websiteOriginId,
+                DomainName: websiteEndpoint({ Ref: outputBucketLogicalId }),
+                CustomOriginConfig: {
+                  HTTPPort: 80,
+                  HTTPSPort: 443,
+                  OriginProtocolPolicy: "http-only"
+                }
+              }
+            ],
+            DefaultCacheBehavior: {
+              TargetOriginId: websiteOriginId,
+              ViewerProtocolPolicy: "redirect-to-https",
+              AllowedMethods: ["GET", "HEAD"],
+              CachedMethods: ["GET", "HEAD"],
+              Compress: true,
+              ForwardedValues: {
+                QueryString: false,
+                Cookies: { Forward: "none" }
+              }
+            },
+            ViewerCertificate: {
+              AcmCertificateArn: runtimeConfig.certificateArn,
+              SslSupportMethod: "sni-only",
+              MinimumProtocolVersion: "TLSv1.2_2021"
+            }
+          }
+        }
+      };
+
+      outputs[`${outputBucketLogicalId}Name`] = { Value: { Ref: outputBucketLogicalId } };
+      outputs[`${distributionLogicalId}Id`] = { Value: { Ref: distributionLogicalId } };
+      outputs[`${distributionLogicalId}Domain`] = { Value: { "Fn::GetAtt": [distributionLogicalId, "DomainName"] } };
+
+      if (runtimeConfig.route53HostedZoneId) {
+        for (const alias of languageConfig.cloudFrontAliases) {
+          const aliasSuffix = sanitizeLogicalId(alias);
+          const aRecordLogicalId = `${distributionLogicalId}${aliasSuffix}ARecord`;
+          const aaaaRecordLogicalId = `${distributionLogicalId}${aliasSuffix}AAAARecord`;
+
+          resources[aRecordLogicalId] = {
+            Type: "AWS::Route53::RecordSet",
+            Properties: {
+              HostedZoneId: runtimeConfig.route53HostedZoneId,
+              Name: alias,
+              Type: "A",
+              AliasTarget: {
+                DNSName: { "Fn::GetAtt": [distributionLogicalId, "DomainName"] },
+                HostedZoneId: "Z2FDTNDATAQYW2"
+              }
+            }
+          };
+
+          resources[aaaaRecordLogicalId] = {
+            Type: "AWS::Route53::RecordSet",
+            Properties: {
+              HostedZoneId: runtimeConfig.route53HostedZoneId,
+              Name: alias,
+              Type: "AAAA",
+              AliasTarget: {
+                DNSName: { "Fn::GetAtt": [distributionLogicalId, "DomainName"] },
+                HostedZoneId: "Z2FDTNDATAQYW2"
+              }
+            }
+          };
+        }
+      }
+    }
+  }
+
+  resources.SourceDispatcherPermission = {
+    Type: "AWS::Lambda::Permission",
+    Properties: {
+      Action: "lambda:InvokeFunction",
+      FunctionName: { Ref: "SourceDispatcher" },
+      Principal: "s3.amazonaws.com"
+    }
+  };
+
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Description: `S3TE environment stack for ${config.project.name} (${environment})`,
+    Parameters: parameters,
+    Resources: resources,
+    Outputs: outputs
+  };
+}
+
+export function buildTemporaryDeployStackTemplate() {
+  return {
+    AWSTemplateFormatVersion: "2010-09-09",
+    Description: "Temporary S3TE packaging stack for Lambda deployment artifacts",
+    Resources: {
+      ArtifactBucket: {
+        Type: "AWS::S3::Bucket",
+        DeletionPolicy: "Delete",
+        UpdateReplacePolicy: "Delete",
+        Properties: {
+          VersioningConfiguration: {
+            Status: "Suspended"
+          }
+        }
+      }
+    },
+    Outputs: {
+      ArtifactBucketName: {
+        Value: { Ref: "ArtifactBucket" }
+      }
+    }
+  };
+}

package/packages/aws-adapter/src/zip.mjs

@@ -0,0 +1,111 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < 256; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = (value & 1) ? (0xEDB88320 ^ (value >>> 1)) : (value >>> 1);
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+
+function crc32(buffer) {
+  let crc = 0xFFFFFFFF;
+  for (const byte of buffer) {
+    crc = CRC_TABLE[(crc ^ byte) & 0xFF] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
+function dosDateTime(date) {
+  const year = Math.max(date.getFullYear(), 1980) - 1980;
+  const month = date.getMonth() + 1;
+  const day = date.getDate();
+  const hours = date.getHours();
+  const minutes = date.getMinutes();
+  const seconds = Math.floor(date.getSeconds() / 2);
+  return {
+    date: (year << 9) | (month << 5) | day,
+    time: (hours << 11) | (minutes << 5) | seconds
+  };
+}
+
+function createLocalHeader(nameBuffer, dataBuffer, modifiedAt) {
+  const { date, time } = dosDateTime(modifiedAt);
+  const header = Buffer.alloc(30);
+  header.writeUInt32LE(0x04034b50, 0);
+  header.writeUInt16LE(20, 4);
+  header.writeUInt16LE(0, 6);
+  header.writeUInt16LE(0, 8);
+  header.writeUInt16LE(time, 10);
+  header.writeUInt16LE(date, 12);
+  header.writeUInt32LE(crc32(dataBuffer), 14);
+  header.writeUInt32LE(dataBuffer.length, 18);
+  header.writeUInt32LE(dataBuffer.length, 22);
+  header.writeUInt16LE(nameBuffer.length, 26);
+  header.writeUInt16LE(0, 28);
+  return header;
+}
+
+function createCentralHeader(nameBuffer, dataBuffer, modifiedAt, offset) {
+  const { date, time } = dosDateTime(modifiedAt);
+  const header = Buffer.alloc(46);
+  header.writeUInt32LE(0x02014b50, 0);
+  header.writeUInt16LE(20, 4);
+  header.writeUInt16LE(20, 6);
+  header.writeUInt16LE(0, 8);
+  header.writeUInt16LE(0, 10);
+  header.writeUInt16LE(time, 12);
+  header.writeUInt16LE(date, 14);
+  header.writeUInt32LE(crc32(dataBuffer), 16);
+  header.writeUInt32LE(dataBuffer.length, 20);
+  header.writeUInt32LE(dataBuffer.length, 24);
+  header.writeUInt16LE(nameBuffer.length, 28);
+  header.writeUInt16LE(0, 30);
+  header.writeUInt16LE(0, 32);
+  header.writeUInt16LE(0, 34);
+  header.writeUInt16LE(0, 36);
+  header.writeUInt32LE(0, 38);
+  header.writeUInt32LE(offset, 42);
+  return header;
+}
+
+function createEndOfCentralDirectory(recordCount, centralSize, centralOffset) {
+  const footer = Buffer.alloc(22);
+  footer.writeUInt32LE(0x06054b50, 0);
+  footer.writeUInt16LE(0, 4);
+  footer.writeUInt16LE(0, 6);
+  footer.writeUInt16LE(recordCount, 8);
+  footer.writeUInt16LE(recordCount, 10);
+  footer.writeUInt32LE(centralSize, 12);
+  footer.writeUInt32LE(centralOffset, 16);
+  footer.writeUInt16LE(0, 20);
+  return footer;
+}
+
+export async function writeZipArchive(outputPath, entries) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+
+  for (const entry of entries) {
+    const nameBuffer = Buffer.from(entry.name.replace(/\\/g, "/"));
+    const dataBuffer = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(entry.data);
+    const modifiedAt = entry.modifiedAt ?? new Date();
+    const localHeader = createLocalHeader(nameBuffer, dataBuffer, modifiedAt);
+    localParts.push(localHeader, nameBuffer, dataBuffer);
+    centralParts.push(createCentralHeader(nameBuffer, dataBuffer, modifiedAt, offset), nameBuffer);
+    offset += localHeader.length + nameBuffer.length + dataBuffer.length;
+  }
+
+  const centralOffset = offset;
+  const centralSize = centralParts.reduce((sum, part) => sum + part.length, 0);
+  const footer = createEndOfCentralDirectory(entries.length, centralSize, centralOffset);
+  const archive = Buffer.concat([...localParts, ...centralParts, footer]);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, archive);
+}