skills / mindrally / skills / deno-typescript 
deno-typescript 
$ npx skills add https://github.com/mindrally/skills --skill deno-typescript SKILL.md 
Deno TypeScript Development 
You are an expert in Deno and TypeScript development with deep knowledge of building secure, modern applications using Deno's native TypeScript support and built-in tooling. 
TypeScript General Guidelines 
Basic Principles 
Use English for all code and documentation 
Always declare types for variables and functions (parameters and return values) 
Avoid using 
any type - create necessary types instead 
Use JSDoc to document public classes and methods 
Write concise, maintainable, and technically accurate code 
Use functional and declarative programming patterns 
No configuration needed - Deno runs TypeScript natively 
Nomenclature 
Use PascalCase for classes, types, and interfaces 
Use camelCase for variables, functions, and methods 
Use kebab-case for file and directory names 
Use UPPERCASE for environment variables 
Use descriptive variable names with auxiliary verbs: 
isLoading , 
hasError , 
canDelete 
Start each function with a verb 
Functions 
Write short functions with a single purpose 
Use arrow functions for simple operations 
Use async/await for asynchronous operations 
Prefer the RO-RO pattern for multiple parameters 
Types and Interfaces 
Prefer interfaces over types for object shapes 
Avoid enums; use const objects with 
as const 
Use Zod for runtime validation with inferred types 
Use 
readonly for immutable properties 
Deno-Specific Guidelines 
Project Structure 

src/ routes/ {resource}/ mod.ts handlers.ts validators.ts middleware/ auth.ts logger.ts services/ {domain}_service.ts types/ mod.ts utils/ mod.ts deps.ts main.ts deno.json 
Module System 
Use ES modules with explicit file extensions 
Use 
deps.ts pattern for centralized dependency management 
Import from URLs or use import maps in 
deno.json 
Use JSR (jsr.io) for Deno-native packages 

// deps.ts - centralized dependencies export { serve } from "https://deno.land/std@0.208.0/http/server.ts" ; export { z } from "https://deno.land/x/zod@v3.22.4/mod.ts" ; // Using import maps in deno.json { "imports" : { "std/" : "https://deno.land/std@0.208.0/" , "hono" : "https://deno.land/x/hono@v3.11.7/mod.ts" } } 
Security Model 
Deno is secure by default. Request only necessary permissions: 

# Run with specific permissions deno run --allow-net --allow-read = ./data --allow-env main.ts # Permission flags --allow-net = example.com # Network access to specific domains --allow-read = ./path # File read access --allow-write = ./path # File write access --allow-env = API_KEY # Environment variable access --allow-run = cmd # Subprocess execution 

// Programmatic permission requests const status = await Deno . permissions . request ( { name : "net" , host : "api.example.com" } ) ; if ( status . state === "granted" ) { // Network access granted } 
HTTP Server with Deno.serve 

// Simple HTTP server Deno . serve ( { port : 8000 } , ( req ) => { const url = new URL ( req . url ) ; if ( url . pathname === "/api/users" && req . method === "GET" ) { return Response . json ( { users : [ ] } ) ; } return new Response ( "Not Found" , { status : 404 } ) ; } ) ; 
Using Hono with Deno 

import { Hono } from "https://deno.land/x/hono/mod.ts" ; const app = new Hono ( ) ; app . get ( "/" , ( c ) => c . text ( "Hello Deno!" ) ) ; app . get ( "/api/users" , ( c ) => c . json ( { users : [ ] } ) ) ; Deno . serve ( app . fetch ) ; 
Using Fresh Framework 

// routes/index.tsx import { PageProps } from "$fresh/server.ts" ; export default function Home ( props : PageProps ) { return ( < div > < h1 > Welcome to Fresh < / h1 > < / div > ) ; } // routes/api/users.ts import { Handlers } from "$fresh/server.ts" ; export const handler : Handlers = { async GET ( _req , _ctx ) { const users = await getUsers ( ) ; return Response . json ( users ) ; } , } ; 
Database Integration 

// Using Deno KV (built-in key-value store) const kv = await Deno . openKv ( ) ; // Set a value await kv . set ( [ "users" , "1" ] , { name : "John" , email : "john@example.com" } ) ; // Get a value const result = await kv . get ( [ "users" , "1" ] ) ; console . log ( result . value ) ; // List values const entries = kv . list ( { prefix : [ "users" ] } ) ; for await ( const entry of entries ) { console . log ( entry . key , entry . value ) ; } 
Environment Variables 

// Access environment variables (requires --allow-env) const apiKey = Deno . env . get ( "API_KEY" ) ; // Using dotenv import { load } from "https://deno.land/std/dotenv/mod.ts" ; const env = await load ( ) ; 
Testing with Built-in Test Runner 

// user_test.ts import { assertEquals , assertRejects } from "https://deno.land/std/assert/mod.ts" ; import { describe , it , beforeEach } from "https://deno.land/std/testing/bdd.ts" ; import { getUser , createUser } from "./user_service.ts" ; describe ( "User Service" , ( ) => { beforeEach ( ( ) => { // Setup } ) ; it ( "should create a user" , async ( ) => { const user = await createUser ( { name : "John" , email : "john@example.com" } ) ; assertEquals ( user . name , "John" ) ; } ) ; it ( "should throw for invalid email" , async ( ) => { await assertRejects ( ( ) => createUser ( { name : "John" , email : "invalid" } ) , Error , "Invalid email" ) ; } ) ; } ) ; // Run tests // deno test --allow-net --allow-read 
Built-in Tooling 

# Formatting deno fmt # Linting deno lint # Type checking deno check main.ts # Bundle deno bundle main.ts bundle.js # Compile to executable deno compile --allow-net main.ts # Documentation generation deno doc main.ts # Dependency inspection deno info main.ts 
Configuration with deno.json 

{ "tasks" : { "dev" : "deno run --watch --allow-net --allow-env main.ts" , "start" : "deno run --allow-net --allow-env main.ts" , "test" : "deno test --allow-net" , "lint" : "deno lint" , "fmt" : "deno fmt" } , "imports" : { "std/" : "https://deno.land/std@0.208.0/" , "@/" : "./src/" } , "compilerOptions" : { "strict" : true , "lib" : [ "deno.window" ] } , "lint" : { "rules" : { "tags" : [ "recommended" ] } } , "fmt" : { "indentWidth" : 2 , "singleQuote" : true } } 
Error Handling 

class AppError extends Error { constructor ( message : string , public statusCode : number = 500 , public code : string = "INTERNAL_ERROR" ) { super ( message ) ; this . name = "AppError" ; } } const handleRequest = async ( req : Request ) : Promise < Response > => { try { return await processRequest ( req ) ; } catch ( error ) { if ( error instanceof AppError ) { return Response . json ( { error : error . message , code : error . code } , { status : error . statusCode } ) ; } console . error ( error ) ; return Response . json ( { error : "Internal Server Error" } , { status : 500 } ) ; } } ; 
Web Standards 
Deno embraces web standards. Use: 

fetch() for HTTP requests 

Request and 
Response objects 

URL and 
URLSearchParams 

Web Crypto API for cryptography 

Streams API for data streaming 

FormData for multipart data 
Performance 
Use web streams for large data processing 
Leverage Deno KV for fast key-value storage 
Use 
Deno.serve for high-performance HTTP 
Compile to standalone executables for deployment Weekly Installs 50 Repository mindrally/skills First Seen Jan 25, 2026 Security Audits Gen Agent Trust Hub Pass Socket Pass Snyk Pass Installed on claude-code 39 opencode 38 gemini-cli 35 codex 31 github-copilot 28 antigravity 24