Toni Villena tonivj5

With this tutorial you will get a valid SSL certificate from Let's Encrypt without having to open any incoming ports. You can use the certificate to enable HTTPS with your reverse proxy (Apache, Nginx, Caddy, ...) or other self hosted service. Since it only uses acme.sh which is a shell script it should work on everything that runs linux.

The tutorial was written for and tested with Duck DNS and deSEC, but you can (in theory, because I did sadly encounter a few bugs/incompatibilities here and there) use every of the 150+ DNS provider supported by acme.sh (there is also a second page at the end!). If you want to use a wildcard certificate I would recommend deSEC because Duck DNS currently has a bug/incompatibility with acme.sh.

If you want to use another DNS provider you can skip right to 2. Install acme.sh, but need to change the parameter --dns YOURDNS in all the commands and set all necessary variables yourself according to t

A few findings from experimenting with isolated declarations:

New required type annotations

Exported variables

Exported variables will need an explicit type annotation (✅ implemented).

export const c1: 1 = 1; // ✔ ok, is explicit

PoC scoped custom element registries in Angular

Render the AppComponent as a custom element

export class AppModule {
  ngDoBootstrap(): void {
    customElements.define('mg-root', createCustomIvyElement(AppComponent));
  }
}

Goal

Postman is a usefull app to build and test APIs, most commonly installed on ubuntu-like systems via snap. On recent distributions of Linux Mint (20 and above), snap installs are no longer possible. The instructions below show how to install Postman via the terminal.

Download Postman

$ wget https://dl.pstmn.io/download/latest/linux64 -O postman.tar.gz

Extract archive

$ sudo tar -xzf postman.tar.gz -C /opt

Make symlink

Nx

https://nx.dev/

Nx is a suite of powerful, extensible dev tools to help you architect, test, and build at any scale — integrating seamlessly with modern technologies and libraries while providing a robust CLI, caching, dependency management, and more.

It has first-class support for many frontend and backend technologies, so its documentation comes in multiple flavours.

	import { prisma } from "~/config/prisma";

	async function executeWithoutTransaction(data: Array<{ name: string }>) {
	return await Promise.all(
	data.map((d) => prisma.projects.create({ data: d }))
	);
	}

	async function executeWithArrayTransaction(data: Array<{ name: string }>) {
	return await prisma.$transaction(

	import parserate from '@iter-tools/parserate';

	const t = {
	token: (value) => ({ type: 'token', value }),
	literal: (value) => ({ type: 'literal', value }),
	};

	const escapes = {
	'"': '"',
	'\\': '\\',

	import glob from 'fast-glob'
	import { build } from 'esbuild'
	import { Project } from 'ts-morph'

	const project = new Project({
	compilerOptions: {
	outDir: 'dist',
	emitDeclarationOnly: true,
	},
	tsConfigFilePath: './tsconfig.json',

	type UnaryFunction<T, R> = (source: T) => R;

	type Pipe<T, L = void, R extends UnaryFunction<any, any>[] = []> =
	T extends []
	? R
	: L extends void
	? T extends [(_: infer P) => infer V, ...infer Rest]
	? Pipe<Rest, V, [...R, UnaryFunction<P, V>]>
	: never[]
	: T extends [(_: L) => infer V, ...infer Rest]

	import {
	Project,
	Type,
	Symbol,
	SymbolFlags,
	Signature,
	Node,
	TypeFormatFlags,
	} from 'ts-morph';