CPANscan

Cron::Toolkit is a Perl module for parsing and evaluating Quartz-style cron expressions with full 7-field support, optional year, and several practical extensions. It handles time zones and Daylight Saving Time correctly and can calculate next and previous run times, check if a given epoch matches, and produce human-readable English descriptions. Notable extras include treating day-of-month and day-of-week together as an AND condition, wrapped weekday ranges like 6-2, and an internal Monday=1 weekday convention. The module can parse complete crontab files with environment variable expansion, emit a readable abstract syntax tree or JSON, and normalize expressions for Quartz or traditional Unix cron. With over 400 data-driven tests covering leap years, DST transitions, and many edge cases, it is a reliable choice when you need precise, timezone-aware scheduling or richer cron features than standard 5-field cron offers.

DBIx::Class::Schema::GraphQL automatically turns a connected DBIx::Class schema into a ready-to-run GraphQL::Schema so you can query and mutate your database without writing schema by hand. It maps table columns to GraphQL scalar types, exposes relationships as fields, and creates a Query root with singular lookups plus all<Source>s queries that support column filtering, logical combinators, ordering, and both offset and cursor pagination. It also generates create, update, patch, and delete mutations for each source and supports composite primary keys. The module returns a GraphQL::Schema object and the original DBIx::Class schema for context so you can pass them straight to GraphQL::Execution. Limitations include unfiltered relationship fields, no nested input objects for mutations, update operations being full by default while patch is used for partial changes, cursor pagination that depends on primary key order, and all nonstandard SQL types mapping to String rather than custom scalars. Overall it is a pragmatic way to expose an existing DBIx::Class model over GraphQL quickly with sensible defaults and predictable constraints.

Excel::Writer::XLSX is a mature Perl module for programmatically creating Excel 2007+ XLSX workbooks. It gives you an object oriented API to build workbooks and worksheets, write strings, numbers, dates, formulas and array formulas, apply rich cell formats, create tables, charts and shapes, insert or embed images, add data validation and conditional formatting, include sparklines and attach VBA projects, and it can write to filenames, filehandles or even scalars while handling UTF‑8. The module aims to mirror Excel features so it is useful for report generation, exporting database queries or automating complex spreadsheets, and it includes helpers for A1 notation, autofit sizing and chart configuration. It does not evaluate formulas itself and stores a placeholder result so Excel will recalculate on open, and large workbooks can use a lot of memory although a set_optimization mode reduces usage. Recent updates in version 1.15 add finer chart formatting including title and axis title styles, allow custom data label positioning, document the autofit utility, and fix several range, row and image handling bugs.

App::DBBrowser is a terminal-based interactive database browser that lets you explore, query and manage SQLite, MySQL/MariaDB, PostgreSQL and many other databases through a consistent menu-driven UI and plugin system. It supports browsing schemas and tables, building SELECT/UPDATE/INSERT/DELETE statements with guided menus, running and exporting queries to CSV, importing data from files or spreadsheets, editing rows, creating and dropping tables, using subqueries, CTEs, window and scalar functions, and a variety of input filters and formatting options. The tool focuses on making common ad hoc database tasks fast and accessible from the console without writing SQL by hand, while still allowing you to edit statements directly when needed. Recent maintenance releases (most recently 2.443) include ODBC fixes for MySQL/MariaDB schema handling, a refactor of table-info routines and changes to how connection data is stored. If you want a powerful, configurable interactive client for exploring and manipulating multiple SQL back ends from the terminal, this module is likely relevant.

Switch::Declare provides a compile-time, lexically-scoped switch/case keyword for Perl that lowers the whole construct to ordinary Perl ops so there is no runtime parser overhead. You write switch (EXPR) { case ... { ... } default { ... } } and the scrutinee is evaluated exactly once, the first matching case wins, and there is no fallthrough. Cases support a compact, predictable pattern grammar including numeric and string literals, regexes, ranges and lists, predicate subs, ref/reftype and isa checks, named constants, runtime comparisons and runtime regexes, and you can destructure the matched value into fresh lexicals with -> PATTERN for convenient per-arm bindings. The implementation is undef and type safe so non-matching or undef inputs do not warn or miscompare, and common string-only switches are automatically lowered to a static hash lookup for fast dispatch. Performance is close to hand-written if/elsif chains for most patterns, with numeric comparisons paying a small extra cost for safety, and the compile-time lowering keeps the generated code tight and efficient. If you want a readable, safe, and performant switch construct that integrates with Perl scoping and offers destructuring it is likely a good fit.

Wanted is a small XS module that extends Perl's built-in wantarray to let a subroutine discover exactly how its return value will be used, which is especially helpful when writing lvalue subs that need to behave differently for assignment, scalar, list, boolean, or specific reference contexts. It provides a simple API including want for testing combinations of contexts, wantref/howmany (or COUNT) to see what kind of reference or how many items are expected, context to get a single human readable context string, and rreturn/lnoreturn helpers for correctly returning from lvalue subs. Wanted is a maintained fork of the older Want module and fixes many crashy edge cases found in ties, threaded code, mod_perl handlers and other invalid contexts while adding safety checks. Recent release v0.1.2 hardens want_lvalue against a rare NULL dereference and adds extra validation of the call frame with no public API changes. Be aware of documented limitations that affect all XS context detectors, notably that lvalue detection can fail inside eval blocks on modern Perls and that want('CODE') may be misleading in scalar context for prototyped subs.

Aion::Env lets a Perl module turn .env or environment values into compile-time constants in the calling package, so you can refer to configuration like BIN_TEST or UNI_TEST as regular constants in code. When you import a name you can supply an isa checker and a default value, and the module will initialize the constant from %ENV, then from a .env file, and finally from the default if nothing else is set. You can validate values with a subroutine or an object that overloads ${} or provides a validate method, and parsing errors throw exceptions. A parse() routine is also provided to load .env files into a hash. The author recommends aligning variable names with your package, and version 0.2 adds parser configuration support via Aion::Env::Etc.

Mojolicious::Plugin::BarefootJS integrates the BarefootJS server runtime into a Mojolicious application by registering a "bf" controller helper that provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. It lets you render compiled BarefootJS marked templates as normal Mojolicious templates and installs the supporting hooks so rendering happens smoothly within each request. If you prefer a framework-free setup, the same runtime can be driven with BarefootJS::Backend::Xslate and Text::Xslate. The plugin is lightweight, focused on wiring the runtime into Mojolicious, and is available under the MIT license.

DBIO is a Perl ORM built on DBI that maps database tables to Perl classes and gives you a resultset API for building queries while keeping database-native behavior. It supports three ways to declare result classes—Cake (DDL-like), Candy (import sugar), and Vanilla—and provides automatic joins from relationship conditions, lazy resultsets, prefetch for eager loading, multi-column keys, and driver-specific SQL features. Native driver modules supply dialect-aware behavior for PostgreSQL, MySQL, SQLite, DuckDB and others, and you can generate classes from an existing schema with dbiogen. DBIO is a fork of DBIx::Class with namespace and implementation changes and is currently pre-1.0, so the core API is substantial and usable while a few edges are still being refined. Choose DBIO if you want a DBIx::Class-like toolkit that stays close to DBI and emphasizes native SQL features, flexible queries, and efficient fetching strategies.

Mojo::Log::Role::Formattable is a small role for Mojo::Log that adds "f" suffixed logging methods such as errorf, infof and debugf which accept printf-style format strings and arguments and produce formatted log messages. You enable it by applying the role to a Mojo::Log instance with with_roles and then call methods like $log->errorf('failed: %s', $@) when you prefer printf-style formatting over concatenation or interpolation. It is a focused, lightweight way to extend Mojolicious logging with familiar sprintf-style message creation.

Data::Image is a small, opinionated Perl data object for carrying image metadata in a structured way. It exposes simple read-only attributes such as author, comment, dt_created (a DateTime), height, width, size, id, url and an optional url_cb callback, and it can hold a Data::Metadata object via the new metadata parameter; all fields are optional and default to undef so the module is handy for passing around image descriptions without dealing with heavy image-processing code. The constructor applies lightweight validation so strings and URLs have sensible length and format checks, numeric fields must be numbers (id must be a positive natural), dt_created must be a DateTime object and url_cb must be a code reference, which helps catch bad data early. It is built on the Mo utility libraries and is useful whenever you need a predictable, validated container for image attributes in applications, APIs, or tests. Recent notable change in v0.06 adds the metadata attribute and updates the id validation to use Mo::utils::Number::check_positive_natural().

Data::Metadata provides a simple object for holding metadata as an optional positive integer identifier and a required list of Data::Metadata::KeyValue objects. You construct it with new(%params) and supply an optional id and a key_values arrayref that must contain one or more Data::Metadata::KeyValue instances; the module validates that id is a positive natural number and that key_values is a nonempty array of the correct object type. It exposes id and key_values accessors and is intended as a lightweight container for grouping key/value metadata items alongside the companion Data::Metadata::KeyValue class. This is the initial 0.01 release.

CPAN::Perl::Releases is a small convenience module that maps every Perl release on CPAN to the relative authors/id path where its distribution tarballs live, so scripts and tools can look up the exact location of official Perl tar.gz, tar.bz2 or tar.xz files without scraping the site. Its main function, perl_tarballs, returns a hashref keyed by compression type with the authors/id path for a given Perl version, while perl_versions lists all versions known to the module and perl_pumpkins returns the PAUSE IDs of the Perl maintainers. The mapping is static data that is updated as new Perl releases are uploaded, making this module useful for mirroring, packaging, or automation tasks that need reliable locations for Perl release archives.

SVG::Barcode::QRCode is a small Perl module that produces QR codes as scalable SVG images, making them easy to embed in web pages or vector documents. You can use it as an object or via the plot_qrcode function and customize error correction level (L, M, Q, H), symbol version or automatic sizing, dot size, colors, margin, id and class attributes, and output dimensions. Defaults are sensible for most uses but you can tweak parameters for higher capacity or visual styling. It is built on SVG::Barcode, works well alongside Text::QRCode, and is released under the Artistic License 2.0.

App::Netdisco is an open source, web‑based network management tool that helps network teams discover, inventory and troubleshoot switched networks by collecting SNMP and other data into a PostgreSQL database. It lets you find a host by MAC or IP and trace it to the exact switch port, change port state, VLAN or PoE settings, build inventory reports by vendor, model and OS, and visualise topology with neighbour maps. The distribution provides a browser UI plus a background backend daemon for polling and job handling, a command line tool for ad hoc tasks, a REST API and plugin hooks so you can extend discovery, reporting and actions. Deployments can be self‑contained under a local Perl environment, run as containers, or integrated with existing infrastructure, and the project documents install and upgrade steps for major Linux and BSD platforms. Requirements include Perl 5.10 or later and PostgreSQL 9.6 or later and some platform packages such as net-snmp and SSL development libraries. Recent releases add permanent API tokens and basic Bearer auth, a new queue status API endpoint, and finer control over discovery job parameters and queuing behaviour to make automation and scripted discovery more flexible. If you manage Ethernet networks with SNMP-capable devices and need a searchable inventory, topology discovery and port-level control, Netdisco is likely relevant.

Test::Load::Helper automates finding and loading Perl test helper files by walking upward from the calling test file and evaluating the nearest helper into a target package, so you no longer need brittle relative require paths. You can override the default helper filename or give a relative helper path to preserve its own directory hierarchy and you can choose the package into which the helper is evaluated so shared fixtures can live in a dedicated namespace. Helpers can chain to parent helpers by also using Test::Load::Helper, common files are evaluated only once per target package to avoid duplication, and traversal can be limited by setting TEST_LOAD_ROOT. Helper files are evaluated under use strict and use warnings and if no helper is found the module quietly does nothing. This is the initial 1.0.0 release.

DBIO::GraphQL inspects a DBIO::Schema and auto-generates a ready-to-run GraphQL::Schema plus a context tied to your DBIO connection so you can immediately execute queries and mutations. It translates SQL column types into GraphQL scalars, exposes DBIO relationships as fields, and creates root Query and Mutation types with plural allX queries that support nested per-column filtering, ordering, offset and cursor pagination, and createX, updateX and deleteX mutations for every source. Composite primary keys are supported and responses include convenience fields such as total, nextCursor and hasNextPage. The module is ideal when you want a fast, convention-driven GraphQL API over an existing DBIO schema without hand-writing types or resolvers. Be aware of documented limitations though, such as unfiltered relationship fields, no nested mutation inputs, full-update semantics for updateX, cursor pagination tied to primary-key order, custom SQL types mapping to String, and no subscription support.

DBIO::SQLite is the SQLite adapter for the DBIO ORM that makes your schema and result classes work naturally with SQLite. Loading this component into a schema pins the storage type to DBIO::SQLite::Storage so connections and SQL generation use SQLite-aware behavior. It brings SQLite-specific features such as native deploy, schema introspection, DDL generation and diffing without needing SQL::Translator, plus savepoints, deferred foreign key checks via the foreign_keys PRAGMA, native database backup and DateTime::Format::SQLite inflation. The driver is autodetected for dbi:SQLite DSNs, integrates with DBIO result classes and the use DBIO Schema => -sqlite shortcut, and runs tests against in-memory databases. The initial 0.900000 release adds the native storage and SQLMaker, deploy/introspect/diff tooling, and requires Perl 5.36 or newer and DBD::SQLite.

DBIO::PostgreSQL::PostGIS is a DBIO result-class component that adds PostGIS spatial support to DBIO::PostgreSQL schemas by automatically inflating columns declared as geometry or geography into lightweight DBIO::PostgreSQL::PostGIS::Geometry objects on read and deflating them to EWKT on write. The inflated geometry objects give convenient accessors for coordinates and helpers to build points with a specified SRID, and the component also promotes your resultset to include spatial query helpers so you can run distance or nearest-neighbor queries or drop into raw spatial SQL when needed. For schema-level operations like ensuring PostGIS is installed or checking its version there is a Storage class you can enable via storage_type, and you can customize or extend the ResultSet by subclassing the provided resultset class. You can turn off automatic inflation on a per-column basis by setting inflate_geometry to 0.

DBIO::PostgreSQL::Async is an asynchronous PostgreSQL storage driver for DBIO that uses EV::Pg and libpq's async protocol to avoid DBI and maximize throughput. It presents non-blocking API calls that return Future objects, supports a pipeline mode to batch queries into a single round trip, and includes prepared statement caching, COPY IN for bulk loading, and LISTEN/NOTIFY for real-time events. It also provides transaction helpers with connection pinning, an async connection pool, and an AccessBroker hook for refreshing connection info, while still offering synchronous fallbacks for callers that need them. The module works with EV-based event loops including AnyEvent, IO::Async via Loop::EV, and Mojolicious, and this first release bundles these async features into a DBIO storage implementation ready for high-performance, event-driven applications.

DBIO::PostgreSQL::Age is a DBIO component that adds Apache AGE graph support to DBIO::PostgreSQL, letting you work with property graphs and openCypher queries from your existing DBIO schema. It swaps the schema storage for DBIO::PostgreSQL::Age::Storage so you get graph lifecycle helpers like create_graph and a cypher(...) method that executes AGE's cypher() SQL function. To use it you load the component in your Schema and ensure each DB connection runs LOAD 'age' and sets the search_path, typically by using on_connect_call => 'load_age'. This module is a good fit if you use Perl with PostgreSQL and want to integrate AGE graph queries into your current DBIO-based application.

DBIO::Oracle is a thin convenience subclass for the DBIO ORM that automatically wires an Oracle-specific storage backend into your schema so you can connect to Oracle databases without hand-configuring storage. It is meant to be used in place of the base DBIO class or via the -ora shortcut and will even fall back to WHERE-clause joins for pre-9.0 Oracle servers. The initial 0.900000 release introduces a full set of Oracle-oriented features including sequence-based auto-increment, LOB binding and chunking, RETURNING INTO support, ROWNUM-based paging, savepoints and NLS session setup, plus native introspection, DDL generation and deployment tooling so DBIO schemas can manage and diff Oracle schemas natively. Use this module when you want DBIO-based applications to speak Oracle SQL and handle Oracle-specific schema and storage behavior with minimal fuss.

DBIO::MySQL::Async is a non-blocking MySQL/MariaDB storage backend for DBIO that talks directly to MariaDB's C client via EV::MariaDB to avoid DBI and squeeze out higher performance. It exposes Future-based async query methods, supports prepared statements, transaction helpers that pin a pooled connection for the transaction, and a pipeline mode that batches multiple queries into a single network round trip for lower latency. The module provides a connection pool with broker support to refresh connection info for new pooled connections and works with EV and common Perl event-loop frameworks such as AnyEvent, IO::Async and Mojolicious. Synchronous DBIO calls are still available but will block by waiting on the returned Future. This is the first release, aimed at apps that need high-throughput, low-latency async database access in Perl.

DBIO::DuckDB is a DBIO schema component that makes DuckDB the storage engine for DBIO-powered apps and exposes DuckDB-native capabilities from your schema objects. When loaded it forces storage_type to DBIO::DuckDB::Storage so you get a DBIO-aware driver built on DBD::DuckDB, a pure-FFI DBI driver that requires libduckdb at runtime, and benefits from DuckDB’s embedded, columnar analytical engine. The module provides high-level helpers and performance paths such as the DuckDB Appender for bulk inserts, an Arrow-aware columnar fetch path, read_csv/read_parquet/read_json table-function helpers, DDL emission and deploy tooling that uses a test-deploy-and-compare upgrade strategy, and introspect/diff support for schema upgrades. It also supplies a PostgreSQL-flavored SQL dialect with INSERT ... RETURNING and savepoint support, Quack client-server RPC helpers for recent libduckdb releases, and a convenient DBIO Schema => -du shortcut. The first release bundles storage, SQLMaker, DDL/Deploy, introspect/diff, Arrow and Appender escape hatches, extension and checkpoint helpers, and a test suite that runs against in-memory DuckDB instances so you can try it without external credentials.

DBIO::MSSQL is a lightweight DBIO subclass that makes DBIO work smoothly with Microsoft SQL Server by automatically selecting the DBIO::MSSQL::Storage and MSSQL-specific SQL dialect when you connect. Install it into your schema or use the provided -ms shortcut and your DBIO connections will handle SQL Server quirks like identity retrieval with SCOPE_IDENTITY, MONEY casting, TOP and ROW_NUMBER() based paging, and compatibility with DBD::ODBC, DBD::MSSQL and a DBD::Sybase/FreeTDS path. It also brings native DDL generation, schema introspection, and deploy/upgrade diffing so you can create, inspect and migrate SQL Server schemas from DBIO. This 0.900.000 initial release packages storage, SQL generation and schema-management features to provide a ready-made MSSQL driver for DBIO users.

DBIO::Sybase is a lightweight DBIO schema component that makes connecting DBIO-based applications to Sybase servers straightforward by automatically configuring the schema to use DBIO::Sybase::Storage when you connect. Use it directly in your schema or via the shortcut use DBIO 'Schema', -syb to pin the Sybase storage type so the driver and features for Sybase backends are applied automatically. The storage layer introspects the server and reblesses into the appropriate subclass, so it supports Sybase ASE and Microsoft SQL Server via DBD::Sybase and includes practical features such as FreeTDS support, DateTime and LOB handling, identity and bulk-insert helpers, native schema introspection and diffing, and Sybase ASE DDL generation. This is the initial standalone release, extracted from the DBIO core to provide focused, production-ready schema management for Sybase environments.

DBIO::MySQL is the MySQL and MariaDB driver component for DBIO that plugs into your DBIO Schema to provide MySQL-aware storage and schema management. Load it with the -mysql shortcut or as a component and DBIO will use DBIO::MySQL::Storage so you can deploy, introspect, diff and generate DDL for tables, indexes, foreign keys and views tailored to MySQL/MariaDB. The distribution also includes MySQL-aware SQLMaker behavior, DateTime parsing for MySQL timestamps, and a deploy workflow that can test changes against a temporary database before applying them. This first release extracts the historical DBIx::Class MySQL functionality into standalone modules, adds MariaDB variants, autodetects mysql DSNs, and exposes per-table engine, charset and collate options for DDL generation.

DBIO::Firebird is a lightweight convenience module for the DBIO ORM that makes using Firebird databases simpler by automatically selecting the Firebird storage implementation for your schema. It is a thin subclass of DBIO that sets the storage class to DBIO::Firebird::Storage when you call connection, so you do not need to configure the storage type yourself. Load it via the "-fb" shortcut when declaring your schema to pin Firebird storage by default. Use this module when your application talks to Firebird (or the related InterBase variant) and you want the DBIO schema to be preconfigured to the correct storage layer.

DBIO::DB2 is a lightweight helper for the DBIO ORM that makes it simple to use IBM DB2 by automatically selecting DBIO::DB2::Storage for your schema when you connect. Load this class into your schema or use the provided -db2 shortcut and call connect with your DSN, username, and password, and the module will set the DB2 storage driver and then hand off to DBIO's normal connection logic. It exists only to pin the DB2 storage implementation for you so you do not need to name the storage class yourself, making DB2-backed DBIO schemas easier to configure.