@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.
- package/README.md +12 -10
- package/dist/package.json +2 -1
- package/dist/src/commands/deploy.js +74 -2
- package/dist/src/commands/index.js +17 -16
- package/dist/src/commands/show.js +302 -0
- package/dist/src/common/aliyunClient/apigwOperations.js +6 -22
- package/dist/src/common/aliyunClient/index.js +3 -2
- package/dist/src/common/aliyunClient/ossOperations.js +194 -1
- package/dist/src/common/constants.js +2 -3
- package/dist/src/common/context.js +4 -1
- package/dist/src/common/domainUtils.js +121 -0
- package/dist/src/common/iacHelper.js +1 -8
- package/dist/src/common/stateBackend/cosStateBackend.js +16 -188
- package/dist/src/common/stateBackend/index.js +2 -0
- package/dist/src/common/stateBackend/lockUtils.js +55 -0
- package/dist/src/common/stateBackend/ossStateBackend.js +27 -199
- package/dist/src/common/stateBackend/remoteStateBackend.js +150 -0
- package/dist/src/common/tencentClient/cosOperations.js +486 -213
- package/dist/src/common/tencentClient/dnspodOperations.js +105 -0
- package/dist/src/common/tencentClient/index.js +5 -1
- package/dist/src/lang/en.js +40 -0
- package/dist/src/lang/zh-CN.js +38 -0
- package/dist/src/stack/aliyunStack/apigwResource.js +35 -0
- package/dist/src/stack/aliyunStack/ossResource.js +73 -19
- package/dist/src/stack/deploy.js +6 -33
- package/dist/src/stack/scfStack/cosResource.js +68 -8
- package/dist/src/types/domains/state.js +13 -0
- package/dist/src/validator/templateRefSchema.js +1 -1
- package/dist/tsconfig.tsbuildinfo +1 -1
- package/package.json +2 -1
- 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
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
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
|
-
|
|
21
|
-
|
|
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.
|
|
24
|
-
Bucket:
|
|
25
|
-
Region:
|
|
26
|
-
|
|
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
|
-
|
|
38
|
-
|
|
39
|
-
|
|
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.
|
|
42
|
-
Bucket:
|
|
43
|
-
Region:
|
|
44
|
-
|
|
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
|
-
|
|
59
|
-
|
|
60
|
-
|
|
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(
|
|
285
|
+
resolve();
|
|
69
286
|
}
|
|
70
287
|
});
|
|
71
288
|
});
|
|
72
|
-
//
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
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(
|
|
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
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
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(
|
|
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
|
-
|
|
143
|
-
|
|
324
|
+
},
|
|
325
|
+
getBucket: async (bucketName, region) => {
|
|
144
326
|
try {
|
|
145
|
-
|
|
146
|
-
|
|
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
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
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
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
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
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
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
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
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
|
-
|
|
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
|
-
|
|
250
|
-
|
|
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
|
-
|
|
266
|
-
|
|
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
|
-
|
|
281
|
-
|
|
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;
|