Worker短链(CloudFlare)

Url-Shorten-Worker 使用 [CloudFlare](https://dash.cloudflare.com/) 的 Worker 实现无服务器部署短链服务器

**相关链接：**
- xyTom 原版(main)：https://github.com/xyTom/Url-Shorten-Worker
- crazypeace 版：https://github.com/crazypeace/Url-Shorten-Worker 、[Url-Shorten-Worker 教程](https://zelikk.blogspot.com/search/label/Url-Shorten-Worker)
- DDD网络科技 版：[GitHub](https://github.com/wandduse/workers_kv_Shortenurl)、[博客教程](https://www.wanuse.com/2024/01/cloudflare-workerskv.html)、[BiLi教程](https://www.bilibili.com/video/BV1Ye411n77u)

## [crazypeace 版](https://github.com/crazypeace/Url-Shorten-Worker)
需要验证密码才能访问创建短链主页，验证通过的才可创建，直接访问调整到指定页面(隐藏该短链服务器)，创建的短链可以通过短链主页删除，并且支持作为短链/图床/网络记事本/网络日记本
1. `Workers 和 Pages——KV` 创建一个命名空间(名称随意)
2. 刚创建的 KV 命名空间添加密钥 `password`，值就是 path密码
3. `Workers 和 Pages` 创建一个 Worker 项目
4. `Worker 项目——设置——变量——KV 命名空间绑定` 变量名称 `LINKS`, KV 命名空间 `选择刚刚创建的命名空间`
5. 复制 [项目代码](https://github.com/crazypeace/Url-Shorten-Worker/raw/main/worker.js) 覆盖原Worker代码
6. 保存并部署
7. 绑定自己域名
`Worker 项目——触发器——自定义域——添加自定义域`，添加你需要设置的域名

进入后台(增删短链)：`https://<Worker项目绑定的域名>/<path密码(KV中设置的password)>`
如我自用的：https://mini.918178.xyz/ai773203918

### Workers_crazypeace
如果需要自定义页面，可以把[项目](https://github.com/crazypeace/Url-Shorten-Worker)拉取到自己仓库进行修改，然后替换Worker中`https://<你的GitHub>.github.io`
```js
const config = {
  no_ref: "off", //控制 HTTP referrer 标头，如果要创建一个隐藏 HTTP Referer 标头的匿名链接，请设置为 "on"
  theme: "",//主页主题，默认主题使用空值。要使用 urlcool 主题，请填写 "theme/urlcool"
  cors: "on",//允许 API 请求的跨域资源共享
  unique_link: false,//如果为 true，则相同的长 url 将被缩短为相同的短 url
  custom_link: true,//允许用户自定义短 URL
  overwrite_kv: false, // 允许用户覆盖现有密钥
  snapchat_mode: false,//访问后，链接将被破坏
  visit_count: false,//计算访问次数
  load_kv: false,//从 Cloudflare KV 加载全部内容(禁用后只能管理本地添加的内容,全部内容通过KV命名空间进行管理)
  system_type: "shorturl", // 短链:shorturl,图床:imghost,网络记事本:pastebin,网络日记本:journal
}

// 键入protect_keylist无法从 UI 和 API 读取、添加、删除
const protect_keylist = [
  "password",
]

let index_html = "https://raw.githubusercontent.com/ai773203918/Url-Shorten-Worker/main/index.html"  //使用我汉化的(仅汉化)
//let index_html = "https://crazypeace.github.io/Url-Shorten-Worker/" + config.theme + "/index.html"  // 调用的页面文件(crazypeace的，也可替换为自己的)
let no_ref_html = "https://crazypeace.github.io/Url-Shorten-Worker/no-ref.html"  // 调用的页面文件(默认为crazypeace的，也可替换为自己的)

// 404提示
const html404 = `<!DOCTYPE html>
  <html>
  <body>
    <h1>404 未找到.</h1>
    <p>未找到您访问的网址.</p>
  </body>
  </html>`

let response_header = {
  "Content-type": "text/html;charset=UTF-8;application/json",
}

if (config.cors == "on") {
  response_header = {
    "Content-type": "text/html;charset=UTF-8;application/json",
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "POST",
    "Access-Control-Allow-Headers": "Content-Type",
  }
}

async function randomString(len) {
  len = len || 6;
  let chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';    /*去掉了容易混淆的字符oOLl,9gq,Vv,Uu,I1 *** Easily confused characters removed */
  let maxPos = chars.length;
  let result = '';
  for (i = 0; i < len; i++) {
    result += chars.charAt(Math.floor(Math.random() * maxPos));
  }
  return result;
}

async function sha512(url) {
  url = new TextEncoder().encode(url)

const url_digest = await crypto.subtle.digest(
    {
      name: "SHA-512",
    },
    url, // The data you want to hash as an ArrayBuffer
  )
  const hashArray = Array.from(new Uint8Array(url_digest)); // 将缓冲区转换为字节数组
  const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
  //console.log(hashHex)
  return hashHex
}

async function checkURL(URL) {
  let str = URL;
  let Expression = /http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/;
  let objExp = new RegExp(Expression);
  if (objExp.test(str) == true) {
    if (str[0] == 'h')
      return true;
    else
      return false;
  } else {
    return false;
  }
}

async function save_url(URL) {
  let random_key = await randomString()
  let is_exist = await LINKS.get(random_key)
  // console.log(is_exist)
  if (is_exist == null) {
    return await LINKS.put(random_key, URL), random_key
  }
  else {
    save_url(URL)
  }
}

async function is_url_exist(url_sha512) {
  let is_exist = await LINKS.get(url_sha512)
  // console.log(is_exist)
  if (is_exist == null) {
    return false
  } else {
    return is_exist
  }
}

async function handleRequest(request) {
  // console.log(request)

// 查KV中的password对应的值 Query "password" in KV
  const password_value = await LINKS.get("password");

/************************/
  // 以下是API接口的处理

if (request.method === "POST") {
    let req = await request.json()
    // console.log(req)

let req_cmd = req["cmd"]
    let req_url = req["url"]
    let req_key = req["key"]
    let req_password = req["password"]

/*
    console.log(req_cmd)
    console.log(req_url)
    console.log(req_key)
    console.log(req_password)
    */

if (req_password != password_value) {
      return new Response(`{"status":500,"key": "", "error":"Error: Invalid password."}`, {
        headers: response_header,
      })
    }

if (req_cmd == "add") {
      if ((config.system_type == "shorturl") && !await checkURL(req_url)) {
        return new Response(`{"status":500, "url": "` + req_url + `", "error":"Error: Url illegal."}`, {
          headers: response_header,
        })
      }

let stat, random_key
      if (config.custom_link && (req_key != "")) {
        // Refuse 'password" as Custom shortURL
        if (protect_keylist.includes(req_key)) {
          return new Response(`{"status":500,"key": "` + req_key + `", "error":"Error: Key in protect_keylist."}`, {
            headers: response_header,
          })
        }

let is_exist = await is_url_exist(req_key)
        if ((!config.overwrite_kv) && (is_exist)) {
          return new Response(`{"status":500,"key": "` + req_key + `", "error":"Error: Specific key existed."}`, {
            headers: response_header,
          })
        } else {
          random_key = req_key
          stat, await LINKS.put(req_key, req_url)
        }
      } else if (config.unique_link) {
        let url_sha512 = await sha512(req_url)
        let url_key = await is_url_exist(url_sha512)
        if (url_key) {
          random_key = url_key
        } else {
          stat, random_key = await save_url(req_url)
          if (typeof (stat) == "undefined") {
            await LINKS.put(url_sha512, random_key)
            // console.log()
          }
        }
      } else {
        stat, random_key = await save_url(req_url)
      }
      // console.log(stat)
      if (typeof (stat) == "undefined") {
        return new Response(`{"status":200, "key":"` + random_key + `", "error": ""}`, {
          headers: response_header,
        })
      } else {
        return new Response(`{"status":500, "key": "", "error":"Error: Reach the KV write limitation."}`, {
          headers: response_header,
        })
      }
    } else if (req_cmd == "del") {
      // Refuse to delete 'password' entry
      if (protect_keylist.includes(req_key)) {
        return new Response(`{"status":500, "key": "` + req_key + `", "error":"Error: Key in protect_keylist."}`, {
          headers: response_header,
        })
      }

await LINKS.delete(req_key)

// 计数功能打开的话, 要把计数的那条KV也删掉 Remove the visit times record
      if (config.visit_count) {
        await LINKS.delete(req_key + "-count")
      }

return new Response(`{"status":200, "key": "` + req_key + `", "error": ""}`, {
        headers: response_header,
      })
    } else if (req_cmd == "qry") {
      // 拒绝查询 '密码'
      if (protect_keylist.includes(req_key)) {
        return new Response(`{"status":500,"key": "` + req_key + `", "error":"Error: Key in protect_keylist."}`, {
          headers: response_header,
        })
      }

let keyList = await LINKS.list()
      if (keyList != null) {
        // 初始化返回数据结构 Init the return struct
        let jsonObjectRetrun = JSON.parse(`{"status":200, "error":"", "kvlist": []}`);

for (var i = 0; i < keyList.keys.length; i++) {
          let item = keyList.keys[i];
          // Hide 'password' from the query all result
          if (protect_keylist.includes(item.name)) {
            continue;
          }
          // Hide '-count' from the query all result
          if (item.name.endsWith("-count")) {
            continue;
          }

let url = await LINKS.get(item.name);

let newElement = { "key": item.name, "value": url };
          // 填充要返回的列表 Fill the return list
          jsonObjectRetrun.kvlist.push(newElement);
        }

return new Response(JSON.stringify(jsonObjectRetrun) , {
          headers: response_header,
        })
      } else {
        return new Response(`{"status":500, "error":"Error: Load keyList failed."}`, {
          headers: response_header,
        })
      }

}

} else if (request.method === "OPTIONS") {
    return new Response(``, {
      headers: response_header,
    })
  }

/************************/
  // 以下是浏览器直接访问worker页面的处理

const requestURL = new URL(request.url)
  const path = requestURL.pathname.split("/")[1]
  const params = requestURL.search;

// console.log(path)
  // 如果path为空, 即直接访问本worker
  // If visit this worker directly (no path)
  if (!path) {
    return Response.redirect("https://nas.918178.xyz:10086", 302)  // 如果没有path子路径则跳转到指定页面
    // 也可直接提示404
    /* new Response(html404, {
      headers: {
        "content-type": "text/html;charset=UTF-8",
      },
      status: 404
    }) */
  }

// 如果path符合password 显示操作页面index.html
  if (path == password_value) {
    let index = await fetch(index_html)
    index = await index.text()
    index = index.replace(/__PASSWORD__/gm, password_value)
    // 操作页面文字修改
    // index = index.replace(/短链系统变身/gm, "")
    return new Response(index, {
      headers: {
        "content-type": "text/html;charset=UTF-8",
      },
    })
  }

// 在KV中查询 短链接 对应的原链接
  // Query the value(long url) in KV by key(short url)
  let value = await LINKS.get(path);
  // console.log(value)

// 如果path是'password', 让查询结果为空, 不然直接就把password查出来了
  if (protect_keylist.includes(path)) {
    value = ""
  }

if (value) {
    // 计数功能
    if (config.visit_count) {
      // 获取并增加访问计数
      let count = await LINKS.get(path + "-count");
      if (count === null) {
        await LINKS.put(path + "-count", "1"); // 初始化为1，因为这是首次访问
      } else {
        count = parseInt(count) + 1;
        await LINKS.put(path + "-count", count.toString());
      }
    }

// 如果阅后即焚模式
    if (config.snapchat_mode) {
      // 删除KV中的记录
      // Remove record before jump to long url
      await LINKS.delete(path)
    }

// 作为一个短链系统, value就是long URL, 需要跳转
    if (config.system_type == "shorturl") {
      // 带上参数部分, 拼装要跳转的最终网址
      // URL to jump finally
      let location;
      if (params) {
        location = value + params
      } else {
        location = value
      }

if (config.no_ref == "on") {
        let no_ref = await fetch(no_ref_html)
        no_ref = await no_ref.text()
        no_ref = no_ref.replace(/{__FINAL_LINK__}/gm, location)
        return new Response(no_ref, {
          headers: {
            "content-type": "text/html;charset=UTF-8",
          },
        })
      } else {
        return Response.redirect(location, 302)
      }
    } else if (config.system_type == "imghost") {
      // 如果是图床
      var blob = base64ToBlob(value)
      return new Response(blob, {
        headers: {'Content-Type': 'text/plain;charset=UTF-8'},
      })
    } else {
      // 如果只是一个单纯的key-value系统, 简单的显示value就行了
      return new Response(value, {
        headers: {'Content-Type': 'text/plain;charset=UTF-8'},
      })
    }
  } else { // 其它 config.system_type 类型
    // If request not in KV, return 404
    return new Response(html404, {
      headers: {
        "content-type": "text/html;charset=UTF-8",
      },
      status: 404
    })
  }
}

addEventListener("fetch", async event => {
  event.respondWith(handleRequest(event.request))
})
```

## [xyTom 原版](https://github.com/xyTom/Url-Shorten-Worker)
最基础的功能，访问主页为创建短链主页，任何人都可创建，创建的短链会存储在KV下(删除也是要去到KV里删除)
1. `Workers 和 Pages——KV` 创建一个命名空间(名称随意)
2. `Workers 和 Pages` 创建一个 Worker 项目
3. `Worker 项目——设置——变量——KV 命名空间绑定` 变量名称 `LINKS`, KV 命名空间 `选择刚刚创建的命名空间`
4. 复制 [项目代码](https://raw.githubusercontent.com/xyTom/Url-Shorten-Worker/main/index.js) 覆盖原Worker代码
5. 保存并部署
6. 绑定自己域名
`Worker 项目——触发器——自定义域——添加自定义域`，添加你需要设置的域名

进入主页：`https://<Worker项目绑定的域名>`

### Worker_xyTom
```js
const config = {
no_ref: "off", //控制 HTTP 引用头，如果要创建匿名链接以隐藏 HTTP 引用头，请设置为 "on"
theme:"",//主页主题，默认主题请使用空值。要使用 urlcool 主题，请填写 "theme/urlcool"
cors: "on",//允许为应用程序接口请求提供跨源资源共享.
unique_link:false,//如果为 "true"，相同的长网址将被缩短为相同的短网址
custom_link:true,//允许用户自定义短网址
safe_browsing_api_key: "" //输入 Google Safe Browsing API Key，在重定向前启用网址安全检查
}

const html404 = `<!DOCTYPE html>
<body>
  <h1>404 未找到.</h1>
  <p>未找到您访问的网址.</p>
</body>`

let response_header={
  "content-type": "text/html;charset=UTF-8",
}

if (config.cors=="on"){
  response_header={
  "content-type": "text/html;charset=UTF-8",
  "Access-Control-Allow-Origin":"*",
  "Access-Control-Allow-Methods": "POST",
  }
}

async function randomString(len) {
　　len = len || 6;
　　let $chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';    /****默认去掉了容易混淆的字符oOLl,9gq,Vv,Uu,I1****/
　　let maxPos = $chars.length;
　　let result = '';
　　for (i = 0; i < len; i++) {
　　　　result += $chars.charAt(Math.floor(Math.random() * maxPos));
　　}
　　return result;
}

async function sha512(url){
    url = new TextEncoder().encode(url)

let raw = JSON.stringify({"client":{"clientId":"Url-Shorten-Worker","clientVersion":"1.0.7"},"threatInfo":{"threatTypes":["MALWARE","SOCIAL_ENGINEERING","POTENTIALLY_HARMFUL_APPLICATION","UNWANTED_SOFTWARE"],"platformTypes":["ANY_PLATFORM"],"threatEntryTypes":["URL"],"threatEntries":[{"url":url}]}});

let requestOptions = {
    method: 'POST',
    body: raw,
    redirect: 'follow'
  };

result = await fetch("https://safebrowsing.googleapis.com/v4/threatMatches:find?key="+config.safe_browsing_api_key, requestOptions)
  result = await result.json()
  console.log(result)
  if (Object.keys(result).length === 0){
    return true
  }else{
    return false
  }
}
async function handleRequest(request) {
  console.log(request)
  if (request.method === "POST") {
    let req=await request.json()
    console.log(req["url"])
    if(!await checkURL(req["url"])){
    return new Response(`{"status":500,"key":": Error: Url illegal."}`, {
      headers: response_header,
    })}
    let stat,random_key
    if (config.unique_link){
      let url_sha512 = await sha512(req["url"])
      let url_key = await is_url_exist(url_sha512)
      if(url_key){
        random_key = url_key
      }else{
        stat,random_key=await save_url(req["url"])
        if (typeof(stat) == "undefined"){
          console.log(await LINKS.put(url_sha512,random_key))
        }
      }
    }else{
      stat,random_key=await save_url(req["url"])
    }
    console.log(stat)
    if (typeof(stat) == "undefined"){
      return new Response(`{"status":200,"key":"/`+random_key+`"}`, {
      headers: response_header,
    })
    }else{
      return new Response(`{"status":200,"key":": Error:Reach the KV write limitation."}`, {
      headers: response_header,
    })}
  }else if(request.method === "OPTIONS"){  
      return new Response(``, {
      headers: response_header,
    })
  }
  const requestURL = new URL(request.url)
  const path = requestURL.pathname.split("/")[1]
  const params = requestURL.search;
  console.log(path)
  if(!path){
    const html= await fetch("https://xytom.github.io/Url-Shorten-Worker/"+config.theme+"/index.html")
    return new Response(await html.text(), {
    headers: {
      "content-type": "text/html;charset=UTF-8",
    },
  })
  }

const value = await LINKS.get(path);
  let location ;

if(params) {
    location = value + params
  } else {
      location = value
  }
  console.log(value)

if (location) {
    if (config.safe_browsing_api_key){
      if(!(await is_url_safe(location))){
        let warning_page = await fetch("https://xytom.github.io/Url-Shorten-Worker/safe-browsing.html")
        warning_page =await warning_page.text()
        warning_page = warning_page.replace(/{Replace}/gm, location)
        return new Response(warning_page, {
          headers: {
            "content-type": "text/html;charset=UTF-8",
          },
        })
      }
    }
    if (config.no_ref=="on"){
      let no_ref= await fetch("https://xytom.github.io/Url-Shorten-Worker/no-ref.html")
      no_ref=await no_ref.text()
      no_ref=no_ref.replace(/{Replace}/gm, location)
      return new Response(no_ref, {
      headers: {
        "content-type": "text/html;charset=UTF-8",
      },
    })
    }else{
      return Response.redirect(location, 302)
    }
  }
  // If request not in kv, return 404
  return new Response(html404, {
    headers: {
      "content-type": "text/html;charset=UTF-8",
    },
    status: 404
  })
}

addEventListener("fetch", async event => {
  event.respondWith(handleRequest(event.request))
})
```