@geek-fun/serverlessinsight 0.5.6 → 0.5.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (31) hide show
  1. package/README.md +12 -10
  2. package/dist/package.json +2 -1
  3. package/dist/src/commands/deploy.js +74 -2
  4. package/dist/src/commands/index.js +17 -16
  5. package/dist/src/commands/show.js +302 -0
  6. package/dist/src/common/aliyunClient/apigwOperations.js +6 -22
  7. package/dist/src/common/aliyunClient/index.js +3 -2
  8. package/dist/src/common/aliyunClient/ossOperations.js +194 -1
  9. package/dist/src/common/constants.js +2 -3
  10. package/dist/src/common/context.js +4 -1
  11. package/dist/src/common/domainUtils.js +121 -0
  12. package/dist/src/common/iacHelper.js +1 -8
  13. package/dist/src/common/stateBackend/cosStateBackend.js +16 -188
  14. package/dist/src/common/stateBackend/index.js +2 -0
  15. package/dist/src/common/stateBackend/lockUtils.js +55 -0
  16. package/dist/src/common/stateBackend/ossStateBackend.js +27 -199
  17. package/dist/src/common/stateBackend/remoteStateBackend.js +150 -0
  18. package/dist/src/common/tencentClient/cosOperations.js +486 -213
  19. package/dist/src/common/tencentClient/dnspodOperations.js +105 -0
  20. package/dist/src/common/tencentClient/index.js +5 -1
  21. package/dist/src/lang/en.js +40 -0
  22. package/dist/src/lang/zh-CN.js +38 -0
  23. package/dist/src/stack/aliyunStack/apigwResource.js +35 -0
  24. package/dist/src/stack/aliyunStack/ossResource.js +73 -19
  25. package/dist/src/stack/deploy.js +6 -33
  26. package/dist/src/stack/scfStack/cosResource.js +68 -8
  27. package/dist/src/types/domains/state.js +13 -0
  28. package/dist/src/validator/templateRefSchema.js +1 -1
  29. package/dist/tsconfig.tsbuildinfo +1 -1
  30. package/package.json +2 -1
  31. package/dist/src/commands/template.js +0 -28
@@ -1,47 +1,151 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.createCosOperations = void 0;
4
- const createCosOperations = (cosClient) => ({
5
- createBucket: async (config) => {
6
- // Create bucket
7
- await new Promise((resolve, reject) => {
8
- cosClient.putBucket({
9
- Bucket: config.Bucket,
10
- Region: config.Region,
11
- }, (err) => {
12
- if (err) {
13
- reject(err);
14
- }
15
- else {
16
- resolve();
4
+ const logger_1 = require("../logger");
5
+ const lang_1 = require("../../lang");
6
+ const domainUtils_1 = require("../domainUtils");
7
+ const createCosOperations = (cosClient, region, dnsOps) => {
8
+ const getCosEndpoint = (bucketName) => {
9
+ return `${bucketName}.cos.${region}.myqcloud.com`;
10
+ };
11
+ const buildCorsRuleForDomain = (domain) => ({
12
+ AllowedOrigin: [`https://${domain}`, `http://${domain}`],
13
+ AllowedMethod: ['GET', 'HEAD'],
14
+ AllowedHeader: ['*'],
15
+ ExposeHeader: ['ETag', 'Content-Length'],
16
+ MaxAgeSeconds: 3600,
17
+ });
18
+ const isDomainCorsRule = (rule, domain) => {
19
+ const origins = rule.AllowedOrigin || [];
20
+ const expected = new Set([`https://${domain}`, `http://${domain}`]);
21
+ return origins.length === expected.size && origins.every((o) => expected.has(o));
22
+ };
23
+ const addCorsRuleForDomain = async (bucketName, domain) => {
24
+ try {
25
+ let existingRules = [];
26
+ try {
27
+ const corsResult = await new Promise((resolve, reject) => {
28
+ cosClient.getBucketCors({ Bucket: bucketName, Region: region }, (err, data) => {
29
+ if (err)
30
+ reject(err);
31
+ else
32
+ resolve(data);
33
+ });
34
+ });
35
+ if (corsResult.CORSRules && corsResult.CORSRules.length > 0) {
36
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
37
+ existingRules = corsResult.CORSRules;
17
38
  }
18
- });
19
- });
20
- // Set ACL if specified
21
- if (config.ACL) {
39
+ }
40
+ catch {
41
+ // no existing CORS config
42
+ }
43
+ if (existingRules.some((rule) => isDomainCorsRule(rule, domain))) {
44
+ logger_1.logger.info(lang_1.lang.__('COS_CORS_RULE_EXISTS', { domain }));
45
+ return;
46
+ }
47
+ const allRules = [...existingRules, buildCorsRuleForDomain(domain)];
22
48
  await new Promise((resolve, reject) => {
23
- cosClient.putBucketAcl({
24
- Bucket: config.Bucket,
25
- Region: config.Region,
26
- ACL: config.ACL,
49
+ cosClient.putBucketCors({
50
+ Bucket: bucketName,
51
+ Region: region,
52
+ CORSRules: allRules.map((r) => ({
53
+ AllowedOrigin: r.AllowedOrigin,
54
+ AllowedMethod: r.AllowedMethod,
55
+ AllowedHeader: r.AllowedHeader || [],
56
+ ExposeHeader: r.ExposeHeader || [],
57
+ MaxAgeSeconds: r.MaxAgeSeconds || 0,
58
+ })),
27
59
  }, (err) => {
28
- if (err) {
60
+ if (err)
29
61
  reject(err);
30
- }
31
- else {
62
+ else
32
63
  resolve();
33
- }
34
64
  });
35
65
  });
66
+ logger_1.logger.info(lang_1.lang.__('COS_CORS_RULE_ADDED', { domain }));
67
+ }
68
+ catch (error) {
69
+ logger_1.logger.warn(lang_1.lang.__('COS_CORS_RULE_ADD_FAILED', { domain, error: String(error) }));
36
70
  }
37
- // Set website configuration if specified
38
- if (config.WebsiteConfiguration) {
39
- const websiteConfig = config.WebsiteConfiguration;
71
+ };
72
+ const removeCorsRuleForDomain = async (bucketName, domain) => {
73
+ try {
74
+ let existingRules = [];
75
+ try {
76
+ const corsResult = await new Promise((resolve, reject) => {
77
+ cosClient.getBucketCors({ Bucket: bucketName, Region: region }, (err, data) => {
78
+ if (err)
79
+ reject(err);
80
+ else
81
+ resolve(data);
82
+ });
83
+ });
84
+ if (corsResult.CORSRules && corsResult.CORSRules.length > 0) {
85
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
86
+ existingRules = corsResult.CORSRules;
87
+ }
88
+ }
89
+ catch {
90
+ return;
91
+ }
92
+ const remainingRules = existingRules.filter((rule) => !isDomainCorsRule(rule, domain));
93
+ if (remainingRules.length === existingRules.length) {
94
+ return;
95
+ }
96
+ if (remainingRules.length > 0) {
97
+ await new Promise((resolve, reject) => {
98
+ cosClient.putBucketCors({
99
+ Bucket: bucketName,
100
+ Region: region,
101
+ CORSRules: remainingRules.map((r) => ({
102
+ AllowedOrigin: r.AllowedOrigin,
103
+ AllowedMethod: r.AllowedMethod,
104
+ AllowedHeader: r.AllowedHeader || [],
105
+ ExposeHeader: r.ExposeHeader || [],
106
+ MaxAgeSeconds: r.MaxAgeSeconds || 0,
107
+ })),
108
+ }, (err) => {
109
+ if (err)
110
+ reject(err);
111
+ else
112
+ resolve();
113
+ });
114
+ });
115
+ }
116
+ else {
117
+ await new Promise((resolve, reject) => {
118
+ cosClient.deleteBucketCors({ Bucket: bucketName, Region: region }, (err) => {
119
+ if (err)
120
+ reject(err);
121
+ else
122
+ resolve();
123
+ });
124
+ });
125
+ }
126
+ logger_1.logger.info(lang_1.lang.__('COS_CORS_RULE_REMOVED', { domain }));
127
+ }
128
+ catch (error) {
129
+ logger_1.logger.warn(lang_1.lang.__('COS_CORS_RULE_REMOVE_FAILED', { domain, error: String(error) }));
130
+ }
131
+ };
132
+ const bindCustomDomain = async (bucketName, domain) => {
133
+ const mainDomain = (0, domainUtils_1.extractMainDomain)(domain);
134
+ const hostRecord = (0, domainUtils_1.extractHostRecord)(domain, mainDomain);
135
+ const cosEndpoint = getCosEndpoint(bucketName);
136
+ let bucketDomainBound = false;
137
+ try {
40
138
  await new Promise((resolve, reject) => {
41
- cosClient.putBucketWebsite({
42
- Bucket: config.Bucket,
43
- Region: config.Region,
44
- WebsiteConfiguration: websiteConfig,
139
+ cosClient.putBucketDomain({
140
+ Bucket: bucketName,
141
+ Region: region,
142
+ DomainRule: [
143
+ {
144
+ Status: 'ENABLED',
145
+ Name: domain,
146
+ Type: 'REST',
147
+ },
148
+ ],
45
149
  }, (err) => {
46
150
  if (err) {
47
151
  reject(err);
@@ -51,99 +155,178 @@ const createCosOperations = (cosClient) => ({
51
155
  }
52
156
  });
53
157
  });
158
+ logger_1.logger.info(lang_1.lang.__('COS_BUCKET_DOMAIN_BOUND', { domain }));
159
+ bucketDomainBound = true;
160
+ }
161
+ catch (error) {
162
+ logger_1.logger.warn(lang_1.lang.__('COS_BUCKET_DOMAIN_BIND_FAILED', { error: String(error) }));
163
+ }
164
+ await addCorsRuleForDomain(bucketName, domain);
165
+ if (!dnsOps) {
166
+ logger_1.logger.warn(lang_1.lang.__('COS_DNS_MANUAL_CONFIG_REQUIRED', { domain, cname: cosEndpoint }));
167
+ return { domain, cname: cosEndpoint, bucketDomainBound };
54
168
  }
55
- },
56
- getBucket: async (bucketName, region) => {
57
169
  try {
58
- // Check if bucket exists
59
- await new Promise((resolve, reject) => {
60
- cosClient.headBucket({
170
+ const existingRecords = await dnsOps.describeDomainRecords(mainDomain, hostRecord);
171
+ const existingRecord = existingRecords.find((record) => record.rr === hostRecord && record.type === 'CNAME' && record.value === cosEndpoint);
172
+ if (existingRecord) {
173
+ logger_1.logger.info(lang_1.lang.__('COS_DNS_CNAME_EXISTS', { domain, cname: cosEndpoint }));
174
+ return {
175
+ domain,
176
+ cname: cosEndpoint,
177
+ dnsRecordId: existingRecord.recordId,
178
+ bucketDomainBound,
179
+ };
180
+ }
181
+ const recordId = await dnsOps.addDomainRecord({
182
+ domainName: mainDomain,
183
+ rr: hostRecord,
184
+ type: 'CNAME',
185
+ value: cosEndpoint,
186
+ ttl: 600,
187
+ });
188
+ logger_1.logger.info(lang_1.lang.__('COS_DNS_CNAME_CREATED', { domain, cname: cosEndpoint }));
189
+ return { domain, cname: cosEndpoint, dnsRecordId: recordId, bucketDomainBound };
190
+ }
191
+ catch (error) {
192
+ logger_1.logger.warn(lang_1.lang.__('COS_DNS_DOMAIN_NOT_MANAGED', { domain, cname: cosEndpoint }));
193
+ logger_1.logger.debug(`DNS error: ${error}`);
194
+ return { domain, cname: cosEndpoint, bucketDomainBound };
195
+ }
196
+ };
197
+ const unbindCustomDomain = async (bucketName, domain, dnsRecordId) => {
198
+ await removeCorsRuleForDomain(bucketName, domain);
199
+ try {
200
+ const existingRules = await new Promise((resolve, reject) => {
201
+ cosClient.getBucketDomain({
61
202
  Bucket: bucketName,
62
203
  Region: region,
63
204
  }, (err, data) => {
205
+ if (err) {
206
+ if (err.statusCode === 404) {
207
+ resolve([]);
208
+ }
209
+ else {
210
+ reject(err);
211
+ }
212
+ }
213
+ else {
214
+ resolve(data?.DomainRule ?? []);
215
+ }
216
+ });
217
+ });
218
+ const remainingRules = existingRules.filter((rule) => rule.Name !== domain);
219
+ if (remainingRules.length < existingRules.length) {
220
+ if (remainingRules.length > 0) {
221
+ await new Promise((resolve, reject) => {
222
+ cosClient.putBucketDomain({
223
+ Bucket: bucketName,
224
+ Region: region,
225
+ DomainRule: remainingRules.map((rule) => ({
226
+ Status: rule.Status,
227
+ Name: rule.Name,
228
+ Type: rule.Type,
229
+ })),
230
+ }, (err) => {
231
+ if (err) {
232
+ reject(err);
233
+ }
234
+ else {
235
+ resolve();
236
+ }
237
+ });
238
+ });
239
+ }
240
+ else {
241
+ await new Promise((resolve, reject) => {
242
+ cosClient.deleteBucketDomain({
243
+ Bucket: bucketName,
244
+ Region: region,
245
+ }, (err) => {
246
+ if (err) {
247
+ reject(err);
248
+ }
249
+ else {
250
+ resolve();
251
+ }
252
+ });
253
+ });
254
+ }
255
+ logger_1.logger.info(lang_1.lang.__('COS_BUCKET_DOMAIN_UNBOUND', { domain }));
256
+ }
257
+ }
258
+ catch (error) {
259
+ logger_1.logger.warn(lang_1.lang.__('COS_BUCKET_DOMAIN_UNBIND_FAILED', { error: String(error) }));
260
+ }
261
+ if (!dnsOps || !dnsRecordId || dnsRecordId === 'existing') {
262
+ return;
263
+ }
264
+ const mainDomain = (0, domainUtils_1.extractMainDomain)(domain);
265
+ try {
266
+ await dnsOps.deleteDomainRecord(mainDomain, dnsRecordId);
267
+ logger_1.logger.info(lang_1.lang.__('COS_DNS_CNAME_DELETED', { domain }));
268
+ }
269
+ catch (error) {
270
+ logger_1.logger.warn(lang_1.lang.__('COS_DNS_CNAME_DELETE_FAILED', { domain, error: String(error) }));
271
+ }
272
+ };
273
+ return {
274
+ createBucket: async (config) => {
275
+ // Create bucket
276
+ await new Promise((resolve, reject) => {
277
+ cosClient.putBucket({
278
+ Bucket: config.Bucket,
279
+ Region: config.Region,
280
+ }, (err) => {
64
281
  if (err) {
65
282
  reject(err);
66
283
  }
67
284
  else {
68
- resolve(data);
285
+ resolve();
69
286
  }
70
287
  });
71
288
  });
72
- // Get ACL
73
- let acl;
74
- let accessControlPolicy;
75
- try {
76
- const aclResult = await new Promise((resolve, reject) => {
77
- cosClient.getBucketAcl({
78
- Bucket: bucketName,
79
- Region: region,
80
- }, (err, data) => {
289
+ // Set ACL if specified
290
+ if (config.ACL) {
291
+ await new Promise((resolve, reject) => {
292
+ cosClient.putBucketAcl({
293
+ Bucket: config.Bucket,
294
+ Region: config.Region,
295
+ ACL: config.ACL,
296
+ }, (err) => {
81
297
  if (err) {
82
298
  reject(err);
83
299
  }
84
300
  else {
85
- resolve(data);
301
+ resolve();
86
302
  }
87
303
  });
88
304
  });
89
- acl = aclResult.ACL;
90
- accessControlPolicy = {
91
- owner: aclResult.Owner
92
- ? {
93
- id: aclResult.Owner.ID,
94
- displayName: undefined,
95
- }
96
- : undefined,
97
- grants: aclResult.Grants?.map((g) => ({
98
- grantee: g.Grantee
99
- ? {
100
- type: 'ID' in g.Grantee ? 'CanonicalUser' : 'Group',
101
- uri: 'URI' in g.Grantee ? g.Grantee.URI : undefined,
102
- id: 'ID' in g.Grantee ? g.Grantee.ID : undefined,
103
- displayName: undefined,
104
- }
105
- : undefined,
106
- permission: g.Permission,
107
- })),
108
- };
109
305
  }
110
- catch {
111
- // ACL might not be accessible due to insufficient permissions
112
- }
113
- // Get CORS configuration
114
- let corsConfiguration;
115
- try {
116
- const corsResult = await new Promise((resolve, reject) => {
117
- cosClient.getBucketCors({
118
- Bucket: bucketName,
119
- Region: region,
120
- }, (err, data) => {
306
+ // Set website configuration if specified
307
+ if (config.WebsiteConfiguration) {
308
+ const websiteConfig = config.WebsiteConfiguration;
309
+ await new Promise((resolve, reject) => {
310
+ cosClient.putBucketWebsite({
311
+ Bucket: config.Bucket,
312
+ Region: config.Region,
313
+ WebsiteConfiguration: websiteConfig,
314
+ }, (err) => {
121
315
  if (err) {
122
316
  reject(err);
123
317
  }
124
318
  else {
125
- resolve(data);
319
+ resolve();
126
320
  }
127
321
  });
128
322
  });
129
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
130
- corsConfiguration = corsResult.CORSRules?.map((r) => ({
131
- id: r.ID,
132
- allowedOrigins: r.AllowedOrigin,
133
- allowedMethods: r.AllowedMethod,
134
- allowedHeaders: r.AllowedHeader,
135
- exposeHeaders: r.ExposeHeader,
136
- maxAgeSeconds: r.MaxAgeSeconds,
137
- }));
138
- }
139
- catch {
140
- // CORS might not be configured
141
323
  }
142
- // Get website configuration
143
- let websiteConfig;
324
+ },
325
+ getBucket: async (bucketName, region) => {
144
326
  try {
145
- const websiteResult = await new Promise((resolve, reject) => {
146
- cosClient.getBucketWebsite({
327
+ // Check if bucket exists
328
+ await new Promise((resolve, reject) => {
329
+ cosClient.headBucket({
147
330
  Bucket: bucketName,
148
331
  Region: region,
149
332
  }, (err, data) => {
@@ -155,133 +338,223 @@ const createCosOperations = (cosClient) => ({
155
338
  }
156
339
  });
157
340
  });
158
- if (websiteResult.WebsiteConfiguration?.IndexDocument ||
159
- websiteResult.WebsiteConfiguration?.ErrorDocument) {
160
- websiteConfig = {
161
- IndexDocument: websiteResult.WebsiteConfiguration.IndexDocument,
162
- ErrorDocument: websiteResult.WebsiteConfiguration.ErrorDocument,
341
+ // Get ACL
342
+ let acl;
343
+ let accessControlPolicy;
344
+ try {
345
+ const aclResult = await new Promise((resolve, reject) => {
346
+ cosClient.getBucketAcl({
347
+ Bucket: bucketName,
348
+ Region: region,
349
+ }, (err, data) => {
350
+ if (err) {
351
+ reject(err);
352
+ }
353
+ else {
354
+ resolve(data);
355
+ }
356
+ });
357
+ });
358
+ acl = aclResult.ACL;
359
+ accessControlPolicy = {
360
+ owner: aclResult.Owner
361
+ ? {
362
+ id: aclResult.Owner.ID,
363
+ displayName: undefined,
364
+ }
365
+ : undefined,
366
+ grants: aclResult.Grants?.map((g) => ({
367
+ grantee: g.Grantee
368
+ ? {
369
+ type: 'ID' in g.Grantee ? 'CanonicalUser' : 'Group',
370
+ uri: 'URI' in g.Grantee ? g.Grantee.URI : undefined,
371
+ id: 'ID' in g.Grantee ? g.Grantee.ID : undefined,
372
+ displayName: undefined,
373
+ }
374
+ : undefined,
375
+ permission: g.Permission,
376
+ })),
163
377
  };
164
378
  }
165
- }
166
- catch {
167
- // Website configuration might not be set
168
- }
169
- // Get versioning configuration
170
- let versioningConfig;
171
- try {
172
- const versioningResult = await new Promise((resolve, reject) => {
173
- cosClient.getBucketVersioning({
174
- Bucket: bucketName,
175
- Region: region,
176
- }, (err, data) => {
177
- if (err) {
178
- reject(err);
179
- }
180
- else {
181
- resolve(data);
182
- }
379
+ catch {
380
+ // ACL might not be accessible due to insufficient permissions
381
+ }
382
+ // Get CORS configuration
383
+ let corsConfiguration;
384
+ try {
385
+ const corsResult = await new Promise((resolve, reject) => {
386
+ cosClient.getBucketCors({
387
+ Bucket: bucketName,
388
+ Region: region,
389
+ }, (err, data) => {
390
+ if (err) {
391
+ reject(err);
392
+ }
393
+ else {
394
+ resolve(data);
395
+ }
396
+ });
183
397
  });
184
- });
185
- versioningConfig = {
186
- status: versioningResult.VersioningConfiguration?.Status,
187
- };
188
- }
189
- catch {
190
- // Versioning might not be accessible
191
- }
192
- // Get tagging configuration
193
- let taggingConfig;
194
- try {
195
- const taggingResult = await new Promise((resolve, reject) => {
196
- cosClient.getBucketTagging({
197
- Bucket: bucketName,
198
- Region: region,
199
- }, (err, data) => {
200
- if (err) {
201
- reject(err);
202
- }
203
- else {
204
- resolve(data);
205
- }
398
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
399
+ corsConfiguration = corsResult.CORSRules?.map((r) => ({
400
+ id: r.ID,
401
+ allowedOrigins: r.AllowedOrigin,
402
+ allowedMethods: r.AllowedMethod,
403
+ allowedHeaders: r.AllowedHeader,
404
+ exposeHeaders: r.ExposeHeader,
405
+ maxAgeSeconds: r.MaxAgeSeconds,
406
+ }));
407
+ }
408
+ catch {
409
+ // CORS might not be configured
410
+ }
411
+ // Get website configuration
412
+ let websiteConfig;
413
+ try {
414
+ const websiteResult = await new Promise((resolve, reject) => {
415
+ cosClient.getBucketWebsite({
416
+ Bucket: bucketName,
417
+ Region: region,
418
+ }, (err, data) => {
419
+ if (err) {
420
+ reject(err);
421
+ }
422
+ else {
423
+ resolve(data);
424
+ }
425
+ });
206
426
  });
207
- });
208
- taggingConfig = {
209
- tags: taggingResult.Tags?.map((t) => ({
210
- key: t.Key,
211
- value: t.Value,
212
- })),
213
- };
214
- }
215
- catch {
216
- // Tagging might not be configured
217
- }
218
- return {
219
- Name: bucketName,
220
- Location: region,
221
- ACL: acl,
222
- WebsiteConfiguration: websiteConfig,
223
- AccessControlPolicy: accessControlPolicy,
224
- CorsConfiguration: corsConfiguration,
225
- VersioningConfiguration: versioningConfig,
226
- TaggingConfiguration: taggingConfig,
227
- };
228
- }
229
- catch (error) {
230
- if (error && typeof error === 'object' && 'statusCode' in error) {
231
- const statusCode = error.statusCode;
232
- if (statusCode === 404) {
233
- return null;
427
+ if (websiteResult.WebsiteConfiguration?.IndexDocument ||
428
+ websiteResult.WebsiteConfiguration?.ErrorDocument) {
429
+ websiteConfig = {
430
+ IndexDocument: websiteResult.WebsiteConfiguration.IndexDocument,
431
+ ErrorDocument: websiteResult.WebsiteConfiguration.ErrorDocument,
432
+ };
433
+ }
234
434
  }
235
- }
236
- throw error;
237
- }
238
- },
239
- updateBucketAcl: async (bucketName, region, acl) => {
240
- await new Promise((resolve, reject) => {
241
- cosClient.putBucketAcl({
242
- Bucket: bucketName,
243
- Region: region,
244
- ACL: acl,
245
- }, (err) => {
246
- if (err) {
247
- reject(err);
435
+ catch {
436
+ // Website configuration might not be set
248
437
  }
249
- else {
250
- resolve();
438
+ // Get versioning configuration
439
+ let versioningConfig;
440
+ try {
441
+ const versioningResult = await new Promise((resolve, reject) => {
442
+ cosClient.getBucketVersioning({
443
+ Bucket: bucketName,
444
+ Region: region,
445
+ }, (err, data) => {
446
+ if (err) {
447
+ reject(err);
448
+ }
449
+ else {
450
+ resolve(data);
451
+ }
452
+ });
453
+ });
454
+ versioningConfig = {
455
+ status: versioningResult.VersioningConfiguration?.Status,
456
+ };
251
457
  }
252
- });
253
- });
254
- },
255
- updateBucketWebsite: async (bucketName, region, websiteConfig) => {
256
- await new Promise((resolve, reject) => {
257
- cosClient.putBucketWebsite({
258
- Bucket: bucketName,
259
- Region: region,
260
- WebsiteConfiguration: websiteConfig,
261
- }, (err) => {
262
- if (err) {
263
- reject(err);
458
+ catch {
459
+ // Versioning might not be accessible
264
460
  }
265
- else {
266
- resolve();
461
+ // Get tagging configuration
462
+ let taggingConfig;
463
+ try {
464
+ const taggingResult = await new Promise((resolve, reject) => {
465
+ cosClient.getBucketTagging({
466
+ Bucket: bucketName,
467
+ Region: region,
468
+ }, (err, data) => {
469
+ if (err) {
470
+ reject(err);
471
+ }
472
+ else {
473
+ resolve(data);
474
+ }
475
+ });
476
+ });
477
+ taggingConfig = {
478
+ tags: taggingResult.Tags?.map((t) => ({
479
+ key: t.Key,
480
+ value: t.Value,
481
+ })),
482
+ };
267
483
  }
268
- });
269
- });
270
- },
271
- deleteBucket: async (bucketName, region) => {
272
- await new Promise((resolve, reject) => {
273
- cosClient.deleteBucket({
274
- Bucket: bucketName,
275
- Region: region,
276
- }, (err) => {
277
- if (err) {
278
- reject(err);
484
+ catch {
485
+ // Tagging might not be configured
279
486
  }
280
- else {
281
- resolve();
487
+ return {
488
+ Name: bucketName,
489
+ Location: region,
490
+ ACL: acl,
491
+ WebsiteConfiguration: websiteConfig,
492
+ AccessControlPolicy: accessControlPolicy,
493
+ CorsConfiguration: corsConfiguration,
494
+ VersioningConfiguration: versioningConfig,
495
+ TaggingConfiguration: taggingConfig,
496
+ };
497
+ }
498
+ catch (error) {
499
+ if (error && typeof error === 'object' && 'statusCode' in error) {
500
+ const statusCode = error.statusCode;
501
+ if (statusCode === 404) {
502
+ return null;
503
+ }
282
504
  }
505
+ throw error;
506
+ }
507
+ },
508
+ updateBucketAcl: async (bucketName, region, acl) => {
509
+ await new Promise((resolve, reject) => {
510
+ cosClient.putBucketAcl({
511
+ Bucket: bucketName,
512
+ Region: region,
513
+ ACL: acl,
514
+ }, (err) => {
515
+ if (err) {
516
+ reject(err);
517
+ }
518
+ else {
519
+ resolve();
520
+ }
521
+ });
522
+ });
523
+ },
524
+ updateBucketWebsite: async (bucketName, region, websiteConfig) => {
525
+ await new Promise((resolve, reject) => {
526
+ cosClient.putBucketWebsite({
527
+ Bucket: bucketName,
528
+ Region: region,
529
+ WebsiteConfiguration: websiteConfig,
530
+ }, (err) => {
531
+ if (err) {
532
+ reject(err);
533
+ }
534
+ else {
535
+ resolve();
536
+ }
537
+ });
538
+ });
539
+ },
540
+ deleteBucket: async (bucketName, region) => {
541
+ await new Promise((resolve, reject) => {
542
+ cosClient.deleteBucket({
543
+ Bucket: bucketName,
544
+ Region: region,
545
+ }, (err) => {
546
+ if (err) {
547
+ reject(err);
548
+ }
549
+ else {
550
+ resolve();
551
+ }
552
+ });
283
553
  });
284
- });
285
- },
286
- });
554
+ },
555
+ bindCustomDomain,
556
+ unbindCustomDomain,
557
+ getCosEndpoint,
558
+ };
559
+ };
287
560
  exports.createCosOperations = createCosOperations;