Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

vercel-deno-dev

Package Overview
Dependencies
Maintainers
1
Versions
191
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

vercel-deno-dev - npm Package Compare versions

Comparing version 0.1.0-b8aaa89e209b2b33e1d3523abeac0f98e8dcd557 to 0.1.0-bbaa82367b46ae0968b89b012e72109b4ac7ac47

53

.github/README.md

@@ -1,5 +0,5 @@

# vercel-deno
# vercel-deno-runtime
> This runtime is currently on development and might be broken on some specific cases specified in the Known Limitation section.
Run Deno runtime on `vercel`. 🦕 + ▲ = ❤️
Deno runtime for `vercel`.

@@ -13,3 +13,3 @@ ## Usage

"api/**/*.{ts,tsx}": {
"runtime": "vercel-deno"
"runtime": "vercel-deno-runtime"
}

@@ -20,4 +20,3 @@ },

"DENO_VERSION":"1.0.5 OR latest",
"DENO_TSCONFIG":"tsconfig.json",
"DENO_FLAGS":"--allow-read",
"DENO_CONFIG":"tsconfig.json",
"DENO_UNSTABLE":true

@@ -30,29 +29,14 @@ }

```ts
// hello.ts
import {
APIGatewayProxyEvent,
APIGatewayProxyResult,
Context
} from "https://deno.land/x/lambda/mod.ts";
export async function handler(
event: APIGatewayProxyEvent,
context: Context
): Promise<APIGatewayProxyResult> {
return {
body: `Welcome to deno ${Deno.version.deno} 🦕`,
headers: { "content-type": "text/html;charset=utf8" },
statusCode: 200
};
// /api/hello.ts
import { NowRequest, NowResponse } from "https://deno.land/x/npm:vercel-deno-runtime/dist/boot/nowHandler.ts";
export default async function handler(req:NowRequest,res:NowResponse) {
res.statuscode(200).send(`Welcome to deno ${Deno.version.deno} 🦕`);
}
```
## Available config ( with default value )
```
DENO_VERSION : "latest"
DENO_TSCONFIG : ""
DENO_FLAGS : "--allow-all"
DENO_UNSTABLE : false
```
## Default configs
- `DENO_VERSION` : "latest"
- `DENO_CONFIG` : ""
- `DENO_UNSTABLE` : false

@@ -62,14 +46,13 @@ Note: `vercel` v17.x or above are required to use the above configuration.

## Known limitation
- Limited to AWS Lambda gateway
- Unable to send response with binary files
- only works on linux, for now.
## TODO
- [ ] Suport Now Launcher
- [ ] Support base64 conversion for binary files response
- [ ] implement caching
- [x] Suport Now Launcher
- [x] Support base64 conversion for binary files response
- [ ] implement caching for downloading deno
- [ ] add support for windows and macos
## Credits
## References
- [deno-lambda](https://github.com/hayd/deno-lambda) by [Andy Hayden](https://github.com/hayd)
- [vercel-deno](https://github.com/TooTallNate/vercel-deno) by [TooTallNate](https://github.com/TooTallNate)
- [now-deno](https://github.com/lucacasonato/now-deno) by [lucacasonato](https://github.com/lucacasonato)

86

dist/boot/runtime.ts

@@ -11,2 +11,3 @@ import * as base64 from 'https://deno.land/x/base64/mod.ts';

interface LambdaContext extends Context {
invokeid:any,
callbackWaitsForEmptyEventLoop: any,

@@ -24,3 +25,4 @@ done: any,

AWS_LAMBDA_LOG_STREAM_NAME,
_HANDLER,
_HANDLER,
LAMBDA_TASK_ROOT,
AWS_LAMBDA_RUNTIME_API

@@ -31,45 +33,14 @@ } = Deno.env.toObject();

const RUNTIME_PATH = '2018-06-01/runtime';
const [HANDLER_FILE,HANDLER_NAME] = _HANDLER.split('.');
async function initialize() {
// const prefix = Deno.env.get('DENO_PREFIX')
// let interpolate = prefix ? (params) => {
// const names = Object.keys(params);
// const vals = Object.values(params);
// return new Function(...names, `return \\\`\${prefix}\\\`;`)(...vals);
// } : (x) => { return '' };
// try {
// interpolate({ requestId: 'a', level: 'TEST' });
// } catch (e) {
// console.log('warn: DENO_PREFIX', e.message);
// interpolate = x => { return ''; };
// }
// const log = console.log;
// In order to support multiline cloudwatch logs we replace \n with \r.
// see https://github.com/hayd/deno-lambda/issues/40
// we also prefix log events with DENO_PREFIX
// const logger = (level) => {
// return (...args) => {
// const prefix = interpolate({ requestId, level })
// const text = Deno[Deno.internal].stringifyArgs(args);
// log((prefix + text).replace(/\n/g, '\r'));
// }
// }
// console.log = logger('INFO');
// console.debug = logger('DEBUG');
// console.info = logger('INFO');
// console.warn = logger('WARN');
// console.error = logger('ERROR');
let handler: NowApiHandler | null = null;
while (true) {
const { event, context } = await invocationNext();
let result;
const { event, context } = await invocationNext();
let handler: NowApiHandler | null = null;
try {
// import lambda function handler dynamically once.
if (!handler) {
const module = await import(`./${_HANDLER}`);
const module = await import(`../${_HANDLER}`);
handler = module.default;

@@ -90,5 +61,5 @@ if (!handler) {

req.url = data.path;
req.proto = 'HTTP/2.0';
req.protoMinor = 0;
req.protoMajor = 2;
req.proto = 'HTTP/1.1';
req.protoMinor = 1;
req.protoMajor = 1;

@@ -130,3 +101,2 @@ for (const [name, value] of Object.entries(data.headers)) {

const statuscode = res ? res.status || 200 : parseInt(firstLine.split(' ', 2)[1], 10); // get statuscode either from res or req.
const headers = await tp.readMIMEHeader() || new Headers();

@@ -144,3 +114,3 @@ const headersObj: { [name: string]: string } = {};

result = {
statuscode: statuscode,
statusCode: statuscode,
headers: headersObj,

@@ -151,3 +121,3 @@ encoding: 'base64',

} catch(e) {
console.error(e);
console.log(e);
continue;

@@ -160,2 +130,4 @@ }

async function invocationResponse(result:any,context:LambdaContext) {
console.log("invoke Response")
console.log({result,context})
const res = await LambdaFetch(`invocation/${context.awsRequestId}/response`, {

@@ -172,3 +144,3 @@ method: 'POST',

);
}
}
}

@@ -183,10 +155,7 @@

const clientcontext:any = () => {
const context = headers.get('lambda-runtime-client-context');
return context ? JSON.parse(context) : undefined;
}
const identity:any = () => {
const cog_iden = headers.get('lambda-runtime-cognito-identity');
return cog_iden ? JSON.parse(cog_iden) : undefined;
}
const clientctx = headers.get('lambda-runtime-client-context');
const clientcontext = clientctx ? JSON.parse(clientctx) : undefined;
const cog_iden = headers.get('lambda-runtime-cognito-identity');
const identity = cog_iden ? JSON.parse(cog_iden) : undefined;

@@ -203,2 +172,3 @@ Deno.env.set('_X_AMZN_TRACE_ID', headers.get('lambda-runtime-trace-id') || '');

awsRequestId: requestId,
invokeid:requestId,
identity:identity,

@@ -227,3 +197,3 @@ clientContext: clientcontext,

body
};
};
}

@@ -302,12 +272,8 @@

// Startpoint.
// Read the code flow from this section first.
try {
await initialize();
} catch (err) {
console.error(err);
Deno.exit(1);
}
catch(e) {
console.error(e);
Deno.exit(1);
}

114

dist/build/index.js

@@ -8,100 +8,38 @@ "use strict";

const fs_extra_1 = __importDefault(require("fs-extra"));
const path_1 = __importDefault(require("path"));
const util_1 = require("./util");
const gatherExtraFiles_1 = __importDefault(require("./gatherExtraFiles"));
const runUserScripts_1 = __importDefault(require("./runUserScripts"));
const grabDenoDirFiles_1 = __importDefault(require("./grabDenoDirFiles"));
const getDenoLambdaLayer_1 = __importDefault(require("./getDenoLambdaLayer"));
const version_1 = require("../version");
const execa_1 = __importDefault(require("execa"));
async function build(opts) {
const { files, entrypoint, workPath: wp, config, meta = {} } = opts;
const workPath = util_1.getWorkPath(wp, entrypoint);
const { files, entrypoint, workPath, meta = {} } = opts;
await fs_extra_1.default.mkdirp(workPath);
// if (meta.isDev) {
// debug('checking that deno is available');
// ensureDeno();
// debug('checking that bash is available');
// ensureBash();
// }
const lambdaFiles = await getDenoLambdaLayer_1.default(workPath, meta.isDev || false);
// if (meta.isDev) {
// debug('symlinking local deno to replace deno-lambda-layer bin/deno');
// await replaceBinDeno(workPath);
// }
console.log("downloading source files");
const downloadedFiles = await build_utils_1.download(files, path_1.default.join(workPath, "src"), meta);
const entryPath = downloadedFiles[entrypoint].fsPath;
await runUserScripts_1.default(entryPath);
const extraFiles = await gatherExtraFiles_1.default(config.includeFiles, entryPath);
return buildDenoLambda(opts, downloadedFiles, extraFiles, lambdaFiles, workPath);
}
exports.default = build;
async function buildDenoLambda({ entrypoint }, downloadedFiles, extraFiles, layerFiles, workPath) {
// Booleans
const unstable = !!process.env.DENO_UNSTABLE;
let tsconfig = "";
try {
const CONFIG = process.env.DENO_TSCONFIG || '';
if (CONFIG) {
tsconfig = downloadedFiles[CONFIG].fsPath || '';
console.log(`using custom typescript config: ${process.env.DENO_TSCONFIG}`);
}
}
catch (err) {
console.log(`DENO_TSCONFIG variable was set to ${process.env.DENO_TSCONFIG}, but no such file exists. ignoring...`);
}
console.log("building single file");
const entrypointPath = downloadedFiles[entrypoint].fsPath;
const entrypointDirname = path_1.default.dirname(entrypointPath);
const extname = path_1.default.extname(entrypointPath);
const binName = path_1.default.basename(entrypointPath).replace(extname, "");
const binPath = path_1.default.join(workPath, binName) + ".bundle.js";
const denoDir = path_1.default.join(workPath, "layer", ".deno_dir");
const denoVer = util_1.parseDenoVersion(process.env.DENO_VERSION || "latest");
console.log("running `deno bundle`...");
try {
const denoBin = layerFiles["bin/deno"].fsPath;
await execa_1.default(denoBin, [
"bundle",
entrypointPath,
binPath,
...(tsconfig && (denoVer.major >= 1) ? ["-c", tsconfig] : []),
...(unstable ? ["--unstable"] : []),
], {
env: {
DENO_DIR: denoDir,
},
cwd: entrypointDirname,
stdio: "pipe",
});
}
catch (err) {
build_utils_1.debug("failed to `deno bundle`");
throw new Error("Failed to run `deno bundle`: " + err.stdout + " " + err.stderr);
}
const denoDirFiles = await grabDenoDirFiles_1.default(denoDir);
const downloadedFiles = await build_utils_1.download(files, workPath, meta);
// configure environment variable
const denoFiles = await util_1.getdenoFiles(workPath, meta.isDev || false);
const bootFiles = await util_1.getbootFiles(workPath);
const cacheFiles = await util_1.CacheEntryPoint(opts, downloadedFiles, denoFiles, bootFiles);
// console.log({downloadedFiles, denoFiles,bootFiles,genFiles})
// Files directory:
// - .deno
// - /deps
// - /gen
// - /bin/deno
// - *.d.ts
// - bootstrap
// - runtime.ts
// - nowHandler.ts
// - helpers.ts
const lambda = await build_utils_1.createLambda({
files: {
...extraFiles,
...layerFiles,
...denoDirFiles,
[binName + ".bundle.js"]: new build_utils_1.FileFsRef({
mode: 0o755,
fsPath: binPath,
}),
...downloadedFiles,
...cacheFiles,
...bootFiles,
...denoFiles
},
handler: binName + ".handler",
runtime: "provided",
environment: {
HANDLER_EXT: "bundle.js",
PATH: process.env.PATH + ":./bin",
DENO_CONFIG: process.env.DENO_CONFIG || ''
},
handler: entrypoint,
runtime: "provided"
});
if (version_1.version === 3) {
return { output: lambda };
}
return {
[entrypoint]: lambda,
};
return { output: lambda };
}
exports.default = build;

149

dist/build/util.js

@@ -6,26 +6,7 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.getWorkPath = exports.parseDenoVersion = exports.getDeno = exports.DENO_VERSION = exports.DENO_LATEST = void 0;
const path_1 = __importDefault(require("path"));
exports.CacheEntryPoint = exports.getbootFiles = exports.getdenoFiles = exports.parseDenoVersion = void 0;
const dist_1 = require("@vercel/build-utils/dist");
const fs_extra_1 = require("fs-extra");
const path_1 = require("path");
const execa_1 = __importDefault(require("execa"));
exports.DENO_LATEST = "latest";
exports.DENO_VERSION = process.env.DENO_VERSION || exports.DENO_LATEST;
async function getDeno(_config, meta) {
if (meta && meta.isDev) {
// Use the system-installed version of `deno` in PATH for `now dev`
const command = "deno --version";
let proc;
if (process.platform === "win32") {
proc = await execa_1.default("cmd.exe", ["/C", command], { stdio: 'pipe' });
}
else {
proc = await execa_1.default("sh", ["-c", command], { stdio: 'pipe' });
}
let deno = proc.stdout.split(/\n/)[0];
return parseDenoVersion(deno);
}
else {
return parseDenoVersion(exports.DENO_VERSION);
}
}
exports.getDeno = getDeno;
function parseDenoVersion(version) {

@@ -43,2 +24,122 @@ if (version === "latest")

exports.parseDenoVersion = parseDenoVersion;
exports.getWorkPath = (workPath, entrypoint) => path_1.default.join(workPath, ".now", "builders", "now-denolis", entrypoint);
async function getdenoFiles(workPath, isDev) {
console.log("get deno binary files");
const DENO_LATEST = "latest";
const DENO_VERSION = process.env.DENO_VERSION || DENO_LATEST;
const DOWNLOAD_URL = DENO_VERSION === DENO_LATEST
? `https://github.com/denoland/deno/releases/latest/download/deno-x86_64-unknown-linux-gnu.zip`
: `https://github.com/denoland/deno/releases/download/v${DENO_VERSION}/deno-x86_64-unknown-linux-gnu.zip`;
const denobinDir = path_1.join(workPath, '.deno/bin/');
const denozipPath = path_1.join(denobinDir, 'deno.zip');
let denoPath = '';
// check if local deno binary exists
if (isDev) {
try {
const checklocalDeno = await execa_1.default('which', ['deno'], { stderr: 'ignore' });
denoPath = checklocalDeno.stdout;
}
catch (e) { }
;
}
if (!denoPath) {
try {
console.log(`downloading deno ${DENO_VERSION}`);
await execa_1.default("curl", ['--location', '--create-dirs', '--output', denozipPath, DOWNLOAD_URL], { stdio: 'pipe' });
console.log(`Extract deno.zip`);
await execa_1.default("unzip", [denozipPath, '-d', denobinDir], { stdio: 'pipe' });
// const {stdout} = await execa(`ls`,[ join(workPath,'.deno/bin/')],{ stdio: 'pipe' });
// console.log(stdout);
// await execa('chmod',['+x',denoPath]);
console.log(`remove deno.zip`);
await execa_1.default("rm", [denozipPath], { stdio: 'pipe' });
denoPath = path_1.join(denobinDir, 'deno');
}
catch (err) {
console.log(err);
throw new Error(err);
}
}
else
console.log('using local deno binary');
return {
".deno/bin/deno": new dist_1.FileFsRef({
mode: 0o755,
fsPath: denoPath,
})
};
}
exports.getdenoFiles = getdenoFiles;
async function getbootFiles(workPath) {
console.log('get bootstrap');
const bootstrapPath = path_1.join(__dirname, "../boot/bootstrap");
const runtimeGlobs = await dist_1.glob("boot/*.ts", { cwd: path_1.join(__dirname, "../") });
const runtimeFiles = await dist_1.download(runtimeGlobs, workPath);
return {
...runtimeFiles,
bootstrap: new dist_1.FileFsRef({
mode: 0o755,
fsPath: bootstrapPath,
})
};
}
exports.getbootFiles = getbootFiles;
/**
* returns .deno files
*/
async function CacheEntryPoint(opts, downloadedFiles, denoFiles, bootFiles) {
console.log(`Caching imports for ${opts.entrypoint}`);
// TODO: create separate function to parse user ENV values
const tsconfig = process.env.DENO_CONFIG ? [`-c`, `${downloadedFiles[process.env.DENO_CONFIG].fsPath}`] : [];
const { workPath, entrypoint } = opts;
const denobinPath = '.deno/bin/deno';
const runtimePath = 'boot/runtime.ts';
const denobin = denoFiles[denobinPath].fsPath;
const runtime = bootFiles[runtimePath].fsPath;
const entry = downloadedFiles[entrypoint].fsPath;
if (denobin && runtime) {
await execa_1.default(denobin, ['cache', ...tsconfig, runtime, entry], {
env: { DENO_DIR: path_1.join(workPath, '.deno/') },
stdio: 'ignore',
});
}
// patch .graph files to use file paths beginning with /var/task
// reference : https://github.com/TooTallNate/vercel-deno/blob/5a236aab30eeb4a6e68216a80f637e687bc59d2b/src/index.ts#L98-L118
const workPathUri = `file://${workPath}`;
for await (const file of getGraphFiles(path_1.join(workPath, '.deno/gen/file'))) {
let needsWrite = false;
const graph = JSON.parse(await fs_extra_1.readFile(file, 'utf8'));
for (let i = 0; i < graph.deps.length; i++) {
const dep = graph.deps[i];
if (dep.startsWith(workPathUri)) {
const updated = `file:///var/task/${dep.substring(workPathUri.length)}`;
graph.deps[i] = updated;
needsWrite = true;
}
}
if (needsWrite) {
console.log('Patched %j', file);
await fs_extra_1.writeFile(file, JSON.stringify(graph));
}
}
// move generated files to AWS path /var/task
const cwd = path_1.join(workPath, '.deno', 'gen', 'file', workPath);
const aws_task = path_1.join(workPath, '.deno', 'gen', 'file', 'var', 'task');
await fs_extra_1.move(cwd, aws_task, { overwrite: true });
return await dist_1.glob(".deno/**/*", { ignore: [".deno/bin/**"] });
}
exports.CacheEntryPoint = CacheEntryPoint;
async function* getGraphFiles(dir) {
const files = await fs_extra_1.readdir(dir);
for (const file of files) {
const absolutePath = path_1.join(dir, file);
if (file.endsWith('.graph')) {
yield absolutePath;
}
else {
const s = await fs_extra_1.stat(absolutePath);
if (s.isDirectory()) {
yield* getGraphFiles(absolutePath);
}
}
}
}

12

dist/prepareCache.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function prepareCache() {
// TODO: add cache here
/// unused.
function prepareCache({ files, entrypoint }) {
console.log("Execute caching for deno");
const deno = files['.deno/bin/deno'].fsPath;
const entry = files[entrypoint].fsPath;
const env = {
...process.env,
DENO_DIR: '/tmp/.deno',
};
console.log({ deno, entry, env });
}
exports.default = prepareCache;

2

package.json
{
"name": "vercel-deno-dev",
"version": "0.1.0-b8aaa89e209b2b33e1d3523abeac0f98e8dcd557",
"version": "0.1.0-bbaa82367b46ae0968b89b012e72109b4ac7ac47",
"description": "run deno on vercel",

@@ -5,0 +5,0 @@ "main": "./dist/index",

dist/build/gatherExtraFiles.js
dist/build/getAWSLambdaHandler.js
dist/build/getDenoLambdaLayer.js
dist/build/grabDenoDirFiles.js
dist/build/runUserScripts.js
dist/boot/bootstrap

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc