wirejs-deploy-amplify-basic 0.0.1-alpha

package/amplify-backend-assets/api-lambda.ts

@@ -0,0 +1,22 @@
+import { env } from 'process';
+
+import { LambdaFunctionURLHandler } from 'aws-lambda';
+
+// import {
+// 	S3Client,
+// 	ListObjectsCommand,
+// 	PutObjectCommand,
+// 	GetObjectCommand
+// } from '@aws-sdk/client-s3';
+
+// import * as api from '../src/api/index.js';
+
+// const s3 = new S3Client()
+
+export const handler: LambdaFunctionURLHandler = async (event, context) => {
+	return {
+		statusCode: 200,
+		cookies: [],
+		body: 'Hello.'
+	}
+}

package/amplify-backend-assets/backend.ts

@@ -0,0 +1,36 @@
+import {
+  defineBackend,
+  defineStorage,
+  defineFunction
+} from '@aws-amplify/backend';
+import { RemovalPolicy } from "aws-cdk-lib";
+import { FunctionUrlAuthType } from 'aws-cdk-lib/aws-lambda';
+
+const api = defineFunction({
+  entry: '../api-lambda.ts',
+})
+
+const storage = defineStorage({
+  name: 'app-data',
+  access: allow => allow.resource(api)
+});
+
+const backend = defineBackend({
+  api,
+  storage,
+});
+
+backend.api.addEnvironment(
+  'BUCKET', backend.storage.resources.bucket.bucketName
+);
+const apiUrl = backend.api.resources.lambda.addFunctionUrl({
+  authType: FunctionUrlAuthType.NONE
+});
+
+backend.storage.resources.bucket.applyRemovalPolicy(RemovalPolicy.RETAIN);
+
+backend.addOutput({
+  custom: {
+    api: apiUrl.url
+  }
+});

package/amplify-backend-assets/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/amplify-backend-assets/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "es2022",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "paths": {
+      "$amplify/*": [
+        "../.amplify/generated/*"
+      ]
+    }
+  }
+}

package/amplify-hosting-assets/compute/default/index.js

@@ -0,0 +1,183 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+
+import { JSDOM } from 'jsdom';
+import { useJSDOM } from 'wirejs-dom/v2';
+import { Context, CookieJar } from 'wirejs-resources';
+
+const SSR_ROOT = path.join(path.dirname(module.filename), 'ssr');
+
+const logger = {
+	log(...items) {
+		console.log('wirejs', ...items);
+	},
+	error(...items) {
+		console.error('wirejs ERROR', ...items);
+	},
+	info(...items) {
+		console.info('wirejs', ...items);
+	},
+	warn(...items) {
+		console.warn('wirejs', ...items);
+	}
+};
+
+/**
+ * Compare two strings by length for sorting in order of increasing length.
+ * 
+ * @param {string} a 
+ * @param {string} b 
+ * @returns 
+ */
+function byLength(a, b) {
+    return a.length - b.length;
+}
+
+/**
+ * @param {string} pattern - string pattern, where `*` matches anything
+ * @param {string} text 
+ * @returns 
+ */
+function globMatch(pattern, text) {
+    const parts = pattern.split('*');
+    const regex = new RegExp(parts.join('.+'));
+    return regex.test(text);
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req 
+ * @returns 
+ */
+function createContext(req) {
+	const { url, headers } = req;
+	const origin = headers.origin || `https://${headers.host}`;
+	const location = new URL(`${origin}${url}`);
+	const cookies = new CookieJar(headers.cookie);
+	return new Context({ cookies, location });
+}
+
+/**
+ * 
+ * @param {Context} context 
+ * @param {string} [forceExt]
+ */
+function routeSSR(context, forceExt) {
+	const asJSPath = forceExt ?
+		context.location.pathname.replace(/\.(\w+)$/, `.${forceExt}`)
+		: context.location.pathname
+	;
+	const allHandlers = fs.readdirSync(SSR_ROOT, { recursive: true })
+		.filter(p => p.endsWith('.js'))
+		.map(p => `/${p}`)
+	;
+	const matchingHandlers = allHandlers.filter(h => globMatch(h, asJSPath));
+	const match = matchingHandlers.sort(byLength).pop();
+
+	if (match) {
+		return path.join(SSR_ROOT, match);
+	}
+}
+
+/**
+ * @param {http.IncomingMessage} req 
+ * @param {http.ServerResponse} res 
+ * @returns 
+ */
+async function trySSRScriptPath(req, res) {
+	const context = createContext(req);
+	const srcPath = routeSSR(context);
+	if (!srcPath) return false;
+
+	logger.info('SSR handler associated script found', srcPath);
+
+	res.setHeader('Content-Type', 'text/javascript');
+
+	try {
+		res.end(fs.readFileSync(srcPath));
+	} catch {
+		res.statusCode = 404;
+		res.end("404 - File not found (c)");
+	}
+
+	return true;
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req
+ * @param {http.ServerResponse} res
+ * @returns 
+ */
+async function trySSRPath(req, res) {
+	const context = createContext(req);
+
+	const asJSPath = context.location.pathname.replace(/\.(\w+)$/, '.js');
+	const srcPath = routeSSR(context, 'js');
+	if (!srcPath) return false;
+
+	logger.info('SSR handler found', srcPath);
+
+	try {
+		useJSDOM(JSDOM);
+		global.self = global.window;
+		await import(srcPath);
+		const module = self.exports;
+		if (typeof module.generate === 'function') {
+			const doc = await module.generate(context);
+			const doctype = doc.parentNode.doctype?.name || '';
+
+			let hydrationsFound = 0;
+			while (globalThis.pendingDehydrations?.length > 0) {
+				globalThis.pendingDehydrations.shift()(doc);
+				hydrationsFound++;
+			}
+
+			if (hydrationsFound) {
+				const script = doc.parentNode.createElement('script');
+				script.src = asJSPath;
+				doc.parentNode.body.appendChild(script);
+			}
+
+			res.setHeader('Content-type', 'text/html; charset=utf-8')
+			res.end([
+				doctype ? `<!doctype ${doctype}>\n` : '',
+				doc.outerHTML
+			].join(''));
+
+			return true;
+		} else {
+			logger.info('SSR module missing generate function');
+			return false;
+		}
+	} catch (error) {
+		logger.error('ssr error', error);
+		res.statusCode = 404;
+		res.end("404 - File not found (a)");
+	}
+
+	return true;
+}
+
+/**
+ * 
+ * @param {http.IncomingMessage} req 
+ * @param {http.ServerResponse} res 
+ * @returns 
+ */
+async function handleRequest(req, res) {
+	logger.info('received', JSON.stringify({ url: req.url }, null, 2));
+
+	if (await trySSRScriptPath(req, res)) return;
+	if (await trySSRPath(req, res)) return;
+
+	// if we've made it this far, we don't have what you're looking for
+	res.statusCode = '404';
+	res.end('404 - Not found');
+}
+
+const server = http.createServer(handleRequest);
+server.listen(3000).on('listening', () => {
+	console.log('Listening on port 3000')
+});

package/amplify-hosting-assets/deploy-manifest.json

@@ -0,0 +1,24 @@
+{
+    "version": 1,
+    "framework": { "name": "express", "version": "4.18.2" },
+    "routes": [
+      {
+        "path": "/*.*",
+        "target": {
+          "kind": "Static",
+          "cacheControl": "public, max-age=2"
+        },
+        "fallback": {
+          "kind": "Compute",
+          "src": "default"
+        }
+      }
+    ],
+    "computeResources": [
+      {
+        "name": "default",
+        "runtime": "nodejs20.x",
+        "entrypoint": "index.js"
+      }
+    ]
+  }

package/build.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+import process from 'process';
+import path from 'path';
+import fs from 'fs';
+import { rimraf } from 'rimraf';
+import copy from 'recursive-copy';
+import esbuild from 'esbuild';
+import { execSync } from 'child_process';
+
+const CWD = process.cwd();
+const SELF_DIR = import.meta.dirname;
+const TEMP_DIR = path.join(SELF_DIR, 'temp');
+const RESOURCE_OVERRIDES_BUILD = path.join(
+	TEMP_DIR, 'wirejs-resource-overrides.build.js'
+);
+const PROJECT_API_DIR = path.join(CWD, 'api');
+const PROJECT_DIST_DIR = path.join(CWD, 'dist');
+const BACKEND_DIR = path.join(CWD, 'amplify');
+const HOSTING_DIR = path.join(CWD, '.amplify-hosting');
+const STATIC_DIR = path.join(HOSTING_DIR, 'static');
+const COMPUTE_DIR = path.join(HOSTING_DIR, 'compute', 'default');
+
+const [_nodeBinPath, _scriptPath, action] = process.argv;
+
+/**
+ * establish Amplify deployment directory skeleton, used by Amplify
+ * to deploy frontend (hosting) and backend (services).
+ */
+async function createSkeleton() {
+	console.log("creating skeleton deployment directories")
+	await rimraf(HOSTING_DIR);
+	await fs.promises.mkdir(HOSTING_DIR, { recursive: true });
+	await fs.promises.mkdir(STATIC_DIR, { recursive: true });
+	await fs.promises.mkdir(COMPUTE_DIR, { recursive: true });
+	
+	// skeleton for backend assets
+	await copy(path.join(SELF_DIR, 'amplify-backend-assets'), path.join(BACKEND_DIR));
+	
+	// skeleton for hosting assets
+	await copy(path.join(SELF_DIR, 'amplify-hosting-assets'), path.join(HOSTING_DIR));
+	console.log("done creating deployment directories")
+}
+
+/**
+ * Install all deps, adding those needed for Amplify backend deployments.
+ */
+async function installDeps() {
+	console.log("adding deps to package.json");
+	// add deps used by Amplify to deploy backend
+	const packageData = JSON.parse(await fs.promises.readFile(path.join(CWD, 'package.json')));
+	packageData.devDependencies = {
+		...(packageData.devDependencies || {}),
+		...{
+			'@aws-amplify/backend': '^1.14.0',
+			'@aws-amplify/backend-cli': '^1.4.8',
+			'aws-cdk': '^2.177.0',
+			'aws-cdk-lib': '^2.177.0',
+			'constructs': '^10.4.2',
+			'esbuild': '^0.24.2',
+			'tsx': '^4.19.2',
+			'typescript': '^5.7.3',
+			'@aws-sdk/client-s3': "^3.735.0",
+		}
+	};
+	await fs.promises.writeFile(
+		path.join(CWD, 'package.json'),
+		JSON.stringify(packageData, null, 2)
+	);
+
+	console.log("installing all deps")
+
+	// install all
+	execSync('npm i');
+
+	console.log("done installing deps")
+}
+
+/**
+ * 
+ * @returns {Promise<string>} output filename
+ */
+async function buildApiBundle() {
+	console.log("building api")
+	// looks like cruft at the moment, but we'll see ...
+	// await import(path.join(PROJECT_API_DIR, 'index.js'));
+
+	const outputPath = path.join(PROJECT_DIST_DIR, 'api', 'dist', 'index.js');
+
+	// intermediate build of the resource overrides. this includes any deps we have
+	// on the original `wirejs-resources` into the intermediate bundle. doing this
+	// allows us to completely override (alias) `wirejs-resources` in the final build
+	// without creating a circular alias.
+	console.log("creating intermediate wirejs-resources overrides");
+	await esbuild.build({
+		entryPoints: [path.join(SELF_DIR, 'wirejs-resources-overrides', 'index.js')],
+		bundle: true,
+		outfile: RESOURCE_OVERRIDES_BUILD,
+		platform: 'node',
+		format: 'esm',
+	});
+
+	// exploratory build. builds using our overrides, which will emit a manifest of
+	// resources required by the API when imported.
+	console.log("creating api bundle using platform overrides");
+	await esbuild.build({
+		entryPoints: [path.join('.', 'api', 'index.js')],
+		bundle: true,
+		outfile: outputPath,
+		platform: 'node',
+		format: 'esm',
+		alias: {
+			'wirejs-resources': RESOURCE_OVERRIDES_BUILD
+		}
+	});
+
+	// exploratory import. not strictly necessary until we're actually using the manifest
+	// to direct construction of backend resources. for now, this is just informational/
+	// confirmational that we're building things properly.
+	await import(outputPath);
+	console.log('discovered resources', globalThis.wirejsResources);
+
+	return outputPath;
+}
+
+async function deployFrontend() {
+	console.log("copying frontend assets");
+	await copy(PROJECT_DIST_DIR, STATIC_DIR);
+
+	// ssr will likely have been build as a static asset, but should NOT be
+	// served as a static resource.
+	await rimraf(path.join(STATIC_DIR, 'ssr'));
+	
+	// instead, ssr should be served from the "compute" directory, served by lambda@edge
+	await copy(
+		path.join(PROJECT_DIST_DIR, 'ssr'),
+		path.join(HOSTING_DIR, 'compute', 'default', 'ssr')
+	);
+	console.log('frontend assets copied');
+}
+
+
+if (action === 'prebuild') {
+	console.log("starting prebuild");
+	await createSkeleton();
+	await installDeps();
+	await buildApiBundle();
+	console.log("prebuild done");
+} else if (action === 'inject-backend') {
+	console.log("starting inject-backend");
+	const config = JSON.parse(await fs.promises.readFile(path.join('.', 'amplify_outputs.json')));
+	const apiUrl = config.custom.api;
+
+	const configJSON = JSON.stringify({
+		apiUrl
+	});
+
+	await fs.promises.writeFile(
+		path.join(PROJECT_API_DIR, 'config.js'),
+		`const config = ${configJSON};\nexport default config;`
+	);
+	console.log("inject-backend done");
+} else if (action === 'build-hosting-artifacts') {
+	console.log("starting build-hosting-artifacts");
+	await deployFrontend();
+	console.log("build-hosting-artifacts done");
+} else {
+	throw new Error("Unrecognized action.");
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "wirejs-deploy-amplify-basic",
+	"version": "0.0.1-alpha",
+	"type": "module",
+	"bin": {
+		"wirejs-deploy-amplify-basic": "./build.js"
+	},
+	"dependencies": {
+		"copy": "^0.3.2",
+		"esbuild": "^0.24.2",
+		"recursive-copy": "^2.0.14",
+		"rimraf": "^6.0.1",
+		"wirejs-resources": "^0.1.5-alpha"
+	},
+	"devDependencies": {
+		"@aws-amplify/backend": "^1.14.0",
+		"@aws-sdk/client-s3": "^3.735.0"
+	}
+}

package/wirejs-resources-overrides/index.js

@@ -0,0 +1,51 @@
+import { overrides } from 'wirejs-resources';
+import { Resource } from 'wirejs-resources';
+
+export {
+	AuthenticationService,
+	withContext,
+	requiresContext,
+	Context,
+	CookieJar,
+	Resource,
+	overrides,
+} from 'wirejs-resources';
+
+export class FileService extends Resource {
+	constructor(scope, id) {
+		super(scope, id);
+		addResource('FileService', { absoluteId: this.absoluteId });
+	}
+
+	async write(...args) {
+		console.log('"writing secret" ... :/ ... ');
+	}
+}
+
+// expose resources to other resources that might depend on it.
+overrides.FileService = FileService;
+
+// export class AuthenticationService {
+// 	constructor(id) {
+// 		addResource('AuthenticationService', { id });
+// 	}
+
+// 	buildApi(...args) {
+// 		// console.log('AuthService.buildApi', [args]);
+// 	}
+// }
+
+// export class Secret {
+// 	constructor(id) {
+// 		addResource('Secret', { id });
+// 	}
+// }
+
+globalThis.wirejsResources = [];
+
+function addResource(type, options) {
+	wirejsResources.push({
+		type,
+		options
+	});
+}

package/wirejs-resources-overrides/package.json

@@ -0,0 +1,12 @@
+{
+	"name": "wirejs-resources-overrides",
+	"version": "0.0.1",
+	"description": "Basic services and server-side resources for wirejs apps",
+	"type": "module",
+	"main": "./index.js",
+	"exports": {
+		".": {
+			"default": "./index.js"
+		}
+	}
+}